Forem: Sébastien LOPEZ

Building a Node.js document intelligence pipeline for under $10/day

Sébastien LOPEZ — Mon, 06 Apr 2026 15:37:23 +0000

You've got 10,000 support tickets, blog posts, or product reviews to process. You need summaries and keywords for each. What does that actually cost?

This post walks through a real Node.js pipeline that processes documents in parallel with rate limiting, error handling, and retry logic — and calculates exactly what you'll pay.

The economics first

Using a pay-per-use API (1 USDC = 1,000 credits):

Operation	Credits	Cost per call	10,000 docs
Summarize	10	$0.01	$100
Keywords	5	$0.005	$50
Both	15	$0.015	$150

No monthly fee. No minimum. Idle months cost $0.

Setting up

npm init -y
npm install node-fetch p-limit

Get a free API key (100 credits, no card needed):

curl -s -X POST https://textai-api.overtek.deno.net/keys/create \
  -H "Content-Type: application/json" \
  -d '{"label":"node-pipeline"}'
# {"apiKey":"sk_...","credits":100}

The pipeline

// pipeline.js
import fetch from 'node-fetch';
import pLimit from 'p-limit';

const API_BASE = 'https://textai-api.overtek.deno.net';
const API_KEY = process.env.TEXTAI_API_KEY;

// Rate limit: 10 concurrent requests max
const limit = pLimit(10);

async function processDoc(doc, retries = 3) {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const [summaryRes, keywordsRes] = await Promise.all([
        fetch(`${API_BASE}/summarize`, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'X-API-Key': API_KEY
          },
          body: JSON.stringify({
            text: doc.text,
            max_sentences: 3
          })
        }),
        fetch(`${API_BASE}/keywords`, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'X-API-Key': API_KEY
          },
          body: JSON.stringify({ text: doc.text, top_n: 5 })
        })
      ]);

      if (!summaryRes.ok || !keywordsRes.ok) {
        throw new Error(`API error: ${summaryRes.status} / ${keywordsRes.status}`);
      }

      const [summary, keywords] = await Promise.all([
        summaryRes.json(),
        keywordsRes.json()
      ]);

      return {
        id: doc.id,
        summary: summary.summary,
        keywords: keywords.keywords,
        creditsUsed: (summary.creditsUsed || 0) + (keywords.creditsUsed || 0)
      };
    } catch (err) {
      if (attempt === retries) throw err;
      // Exponential backoff: 1s, 2s, 4s
      await new Promise(r => setTimeout(r, 1000 * 2 ** (attempt - 1)));
    }
  }
}

async function processBatch(documents) {
  console.log(`Processing ${documents.length} documents...`);
  const start = Date.now();
  let totalCredits = 0;
  let errors = 0;

  const tasks = documents.map(doc =>
    limit(() => processDoc(doc)
      .then(result => {
        totalCredits += result.creditsUsed;
        return result;
      })
      .catch(err => {
        errors++;
        console.error(`Failed doc ${doc.id}: ${err.message}`);
        return { id: doc.id, error: err.message };
      })
    )
  );

  const results = await Promise.all(tasks);
  const elapsed = ((Date.now() - start) / 1000).toFixed(1);

  console.log(`Done in ${elapsed}s`);
  console.log(`Credits used: ${totalCredits} ($${(totalCredits * 0.00001).toFixed(4)})`);
  console.log(`Errors: ${errors}/${documents.length}`);

  return results;
}

// Example usage
const docs = Array.from({ length: 50 }, (_, i) => ({
  id: `doc_${i}`,
  text: `Document ${i}: The quick brown fox jumps over the lazy dog. This is sample content that needs to be summarized and have keywords extracted from it for demonstration purposes.`
}));

processBatch(docs).then(results => {
  console.log('Sample result:', JSON.stringify(results[0], null, 2));
});

Running it

TEXTAI_API_KEY=sk_your_key node pipeline.js
# Processing 50 documents...
# Done in 8.3s
# Credits used: 750 ($0.0075)
# Errors: 0/50

50 documents, under a cent, 8 seconds.

Scaling to 10,000 documents

The same code handles 10,000 docs — just change the input array. With 10 concurrent requests and ~200ms average latency per pair of calls:

Throughput: ~50 docs/second
Time for 10k docs: ~3.3 minutes
Cost: 150,000 credits = 150 USDC = $150

For most pipelines, you'd run this overnight or as a scheduled job. Total infrastructure: one Node.js script and a few dollars of USDC.

Cost optimization tips

1. Only extract what you need. Keywords alone is 5 credits vs 15 for both. If you just need tagging, skip summarization.

2. Chunk large documents. The API processes up to 50,000 characters. For longer docs, split into sections and summarize each, then summarize the summaries.

function chunkText(text, maxChars = 40000) {
  const chunks = [];
  for (let i = 0; i < text.length; i += maxChars) {
    chunks.push(text.slice(i, i + maxChars));
  }
  return chunks;
}

3. Cache results. If you're re-processing documents that haven't changed, cache by content hash to avoid re-spending credits.

import crypto from 'crypto';

const cache = new Map();

function hashDoc(text) {
  return crypto.createHash('sha256').update(text).digest('hex').slice(0, 16);
}

async function processDocCached(doc) {
  const key = hashDoc(doc.text);
  if (cache.has(key)) return { ...cache.get(key), id: doc.id, cached: true };
  const result = await processDoc(doc);
  cache.set(key, result);
  return result;
}

Error handling patterns

The pipeline above uses retry with exponential backoff. For production, also handle:

Credit exhaustion: Check creditsRemaining in each response and top up proactively
Rate limits: The 429 response means slow down — p-limit handles this via concurrency control
Partial failures: Log failed doc IDs and re-run just those after fixing the issue

What this is good for

Content pipelines: Summarize RSS feeds, news articles, research papers automatically
SEO tools: Extract keywords from competitor content at scale
Support ticket triage: Auto-tag and summarize incoming tickets before routing
Newsletter curation: Summarize 100 articles to pick the best 10

The pay-per-use model means you pay for actual processing, not capacity. Process 50 docs or 50,000 — the math is linear.

TextAI API is launching on Product Hunt today. Try it free (100 credits, no card): https://textai-api.overtek.deno.net

Launching on Product Hunt tomorrow: pay-per-use text AI with USDC micropayments (no subscription, 100 free credits)

Sébastien LOPEZ — Mon, 06 Apr 2026 13:36:06 +0000

Tomorrow (April 7 at 12:01 AM PDT) I'm launching TextAI API on Product Hunt. Here's the 2-minute story of why I built it and what it does.

The problem: $0.30 kills micropayments

I wanted to build a text processing pipeline — summarize articles, extract keywords, translate content. The usual suspects (OpenAI, AWS Comprehend) either require monthly subscriptions or charge minimum fees that make per-call pricing uneconomical.

The math is brutal: Stripe charges $0.30 + 2.9% per transaction. If your API call costs $0.01, the payment processing fee is 30x the product cost. You're forced to bundle users into monthly plans just to make the economics work.

I wanted a different model: pay exactly for what you call, with no minimum.

The solution: USDC on Solana

Solana transaction fees are ~$0.00025. That makes true micropayments viable at any scale.

TextAI API works like a prepaid SIM card:

Get an API key (instant, no email required)
Top up with USDC credits when you need them
Pay per call — nothing when idle

# Get your key + 100 free credits in one call
curl -X POST https://textai-api.overtek.deno.net/keys/create \
  -H "Content-Type: application/json" \
  -d '{"label":"test"}'
# → {"apiKey":"sk_...","credits":100}

What it does today

Three endpoints, all REST:

Endpoint	What it does	Credits
`POST /summarize`	Condense text to N sentences	10 ($0.01)
`POST /keywords`	Extract top keywords/phrases	5 ($0.005)
`POST /translate`	Translate to 10 languages	15 ($0.015)

1 USDC = 1,000 credits. Process 1,000 documents for ~$5-10 depending on operation mix.

The stack

Built on Deno Deploy + Hono (the fastest JS framework I've tried). SQLite for key/credit storage. The AI engine uses rule-based processing by default with Groq (llama-3.1-8b) when configured — keeps costs near zero at small scale.

The whole thing is ~600 lines of TypeScript.

Try it before the launch

New keys get 100 free demo credits — enough to test all 3 endpoints. No credit card, no email, no account creation.

import requests

# Step 1: get your key
res = requests.post("https://textai-api.overtek.deno.net/keys/create",
    json={"label": "devto-test"})
key = res.json()["apiKey"]

# Step 2: summarize something
result = requests.post("https://textai-api.overtek.deno.net/summarize",
    headers={"X-API-Key": key},
    json={"text": "Your long article here...", "sentences": 3})
print(result.json())

Support on Product Hunt 🚀

If this solves a real problem for you, I'd love your support tomorrow:

👉 TextAI API on Product Hunt

The launch goes live April 7 at 12:01 AM PDT. Any upvotes, comments, or honest feedback are genuinely appreciated.

What would you build with pay-per-use text AI? Drop a comment below — I read every one.

Summarize 1,000 documents with Python for under $1 (pay-per-use AI API)

Sébastien LOPEZ — Mon, 06 Apr 2026 12:39:26 +0000

Every Python developer eventually needs to summarize text at scale — customer feedback, support tickets, news articles, research papers. The typical path is OpenAI ($20/month minimum) or building your own pipeline (weeks of work).

There's a simpler option: a pay-per-use REST API that costs $0.01 per summarization with no subscription, no setup overhead, and a free tier to test with.

The math

1 USDC = 1,000 credits
Summarize = 10 credits ($0.01 per call)
1,000 documents = $10 total

No monthly fee. No minimum commitment.

30-second quickstart

First, get a free API key (100 demo credits included — no payment needed):

curl -X POST https://textai-api.overtek.deno.net/keys/create \
  -H "Content-Type: application/json" \
  -d '{"label":"my-python-project"}'

Response:

{"apiKey": "sk_abc123...", "credits": 100, "demo": true}

Python client

import requests

API_KEY = "sk_abc123..."  # from the step above
BASE_URL = "https://textai-api.overtek.deno.net"

def summarize(text: str, sentences: int = 3) -> str:
    response = requests.post(
        f"{BASE_URL}/summarize",
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={"text": text, "sentences": sentences}
    )
    response.raise_for_status()
    return response.json()["summary"]

def extract_keywords(text: str, max_keywords: int = 10) -> list[str]:
    response = requests.post(
        f"{BASE_URL}/keywords",
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={"text": text, "maxKeywords": max_keywords}
    )
    response.raise_for_status()
    return response.json()["keywords"]

Batch processing example

Here's a realistic pipeline that processes 1,000 documents, checks credit balance, and tops up if needed:

import requests
import time
from pathlib import Path

API_KEY = "sk_abc123..."
BASE_URL = "https://textai-api.overtek.deno.net"
HEADERS = {"X-API-Key": API_KEY, "Content-Type": "application/json"}

def get_balance() -> int:
    r = requests.get(f"{BASE_URL}/credits/balance", headers=HEADERS)
    return r.json()["credits"]

def summarize_batch(documents: list[str], delay_ms: int = 100) -> list[dict]:
    results = []
    for i, doc in enumerate(documents):
        try:
            r = requests.post(
                f"{BASE_URL}/summarize",
                headers=HEADERS,
                json={"text": doc, "sentences": 2}
            )
            r.raise_for_status()
            data = r.json()
            results.append({
                "index": i,
                "summary": data["summary"],
                "credits_used": data["creditsUsed"],
                "credits_remaining": data["creditsRemaining"]
            })
            if (i + 1) % 100 == 0:
                print(f"Processed {i+1} docs — {data['creditsRemaining']} credits left")
            time.sleep(delay_ms / 1000)
        except requests.HTTPError as e:
            if e.response.status_code == 402:
                print(f"Out of credits at doc {i}. Top up at POST /credits/buy")
                break
            results.append({"index": i, "error": str(e)})
    return results

# Process documents
docs = [Path(f).read_text() for f in Path("./documents").glob("*.txt")]
print(f"Starting batch: {len(docs)} documents, ~{len(docs) * 10} credits needed")
print(f"Current balance: {get_balance()} credits")

summaries = summarize_batch(docs)
print(f"Done! Processed {len(summaries)} documents")

Checking your credit balance

r = requests.get(
    "https://textai-api.overtek.deno.net/credits/balance",
    headers={"X-API-Key": API_KEY}
)
print(r.json())
# {"credits": 85, "apiKey": "sk_abc123...", "demo": true}

Topping up with USDC

When you're ready to process at scale (beyond the free 100 credits), top up with USDC on Solana devnet:

# Step 1: Get wallet address
r = requests.post(
    "https://textai-api.overtek.deno.net/credits/buy",
    headers=HEADERS,
    json={"amount": 1}  # 1 USDC = 1,000 credits
)
print(r.json())
# {"walletAddress": "ABC...", "amount": 1, "network": "devnet"}

# Step 2: Send 1 USDC to that address (via any Solana wallet)

# Step 3: Confirm
r = requests.post(
    "https://textai-api.overtek.deno.net/credits/confirm",
    headers=HEADERS,
    json={"txSignature": "your-solana-tx-hash"}
)
print(r.json())
# {"credits": 1000, "added": 1000}

Full pricing reference

Endpoint	Credits	Cost per 1,000 calls
`POST /summarize`	10 credits	$10
`POST /keywords`	5 credits	$5
`POST /translate`	15 credits	$15

When to use this vs. OpenAI

Use TextAI API when: batch processing, cost predictability, no need for GPT-4 quality, want micropayments
Use OpenAI when: you need frontier model reasoning, complex prompts, or generation (not just extraction)

For summarization and keyword extraction from structured content (support tickets, product reviews, news), a lightweight API like this is 10–50x cheaper than frontier models.

Try it: get your free API key at textai-api.overtek.deno.net and process your first 10 documents for free.

What are you building with text processing? Drop a comment below!

Automate SEO keyword tagging with Node.js for under $0.01 per page

Sébastien LOPEZ — Mon, 06 Apr 2026 07:38:20 +0000

If you run a blog, a content site, or any kind of publication, you know the pain: every post needs tags, categories, and meta keywords. Done manually, it's tedious. Done with an LLM subscription, it's overkill — you're paying a monthly fee for a task that takes milliseconds per page.

This tutorial shows how to build an automatic SEO keyword tagger in Node.js using a pay-per-use keyword extraction API. Total cost: under $0.01 per page. No subscription required.

What we're building

A Node.js script that:

Reads URLs from a list (or a sitemap)
Fetches the page text
Extracts the top 10 keywords via API
Outputs a JSON file mapping URL → keywords (ready to push to your CMS or meta tags)

The API

We'll use TextAI API — a pay-per-use REST API with USDC micropayments on Solana.

Pricing for keyword extraction: 5 credits per call. 1 USDC = 1,000 credits, so that's $0.005 per call. Under $0.01 per page.

New accounts get 100 free credits instantly — no credit card, just a POST request.

Setup

npm init -y
npm install node-fetch

Get your free API key:

curl -X POST https://textai-api.overtek.deno.net/keys/create

Response:

{
  "apiKey": "tai_xxxxxxxxxxxx",
  "credits": 100,
  "message": "100 free demo credits included"
}

Save the key:

export TEXTAI_API_KEY=tai_xxxxxxxxxxxx

The tagger script

// seo-tagger.js
import fetch from 'node-fetch';

const API_KEY = process.env.TEXTAI_API_KEY;
const API_URL = 'https://textai-api.overtek.deno.net';

// Your pages — swap this for a sitemap parser or CMS API call
const pages = [
  { url: 'https://example.com/blog/how-to-build-rest-apis', text: 'REST APIs are the backbone of modern web apps. In this guide we cover routing, authentication, rate limiting...' },
  { url: 'https://example.com/blog/node-performance-tips', text: 'Node.js performance optimization starts with event loop management. Avoid blocking I/O, use streams...' },
  { url: 'https://example.com/blog/javascript-closures', text: 'A closure is the combination of a function and the lexical environment within which that function was declared...' },
];

async function extractKeywords(text, maxKeywords = 10) {
  const response = await fetch(`${API_URL}/keywords`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': API_KEY,
    },
    body: JSON.stringify({ text, max_keywords: maxKeywords }),
  });

  if (!response.ok) {
    const err = await response.json();
    throw new Error(`API error: ${err.error || response.status}`);
  }

  return response.json();
}

async function tagAllPages(pages) {
  const results = [];

  for (const page of pages) {
    try {
      const data = await extractKeywords(page.text);
      results.push({
        url: page.url,
        keywords: data.keywords,
        credits_used: data.credits_used,
        credits_remaining: data.credits_remaining,
      });
      console.log(`✓ ${page.url} → [${data.keywords.slice(0,5).join(', ')}...]`);
    } catch (err) {
      console.error(`✗ ${page.url}: ${err.message}`);
      results.push({ url: page.url, keywords: [], error: err.message });
    }
  }

  return results;
}

// Run
const tagged = await tagAllPages(pages);
console.log('\n--- Results ---');
console.log(JSON.stringify(tagged, null, 2));

// Total cost estimate
const totalCalls = tagged.filter(r => !r.error).length;
const totalCredits = totalCalls * 5;
console.log(`\nTotal: ${totalCalls} pages, ${totalCredits} credits (~$${(totalCredits / 1000).toFixed(4)} USDC)`);

Run it:

node --experimental-vm-modules seo-tagger.js

Example output:

✓ https://example.com/blog/how-to-build-rest-apis → [REST API, authentication, routing, web apps, rate limiting...]
✓ https://example.com/blog/node-performance-tips → [Node.js, event loop, performance, I/O, streams...]
✓ https://example.com/blog/javascript-closures → [closure, lexical scope, JavaScript, function, environment...]

--- Results ---
[
  {
    "url": "https://example.com/blog/how-to-build-rest-apis",
    "keywords": ["REST API", "authentication", "routing", "web apps", "rate limiting", "HTTP", "JSON", "middleware", "endpoint", "security"],
    "credits_used": 5,
    "credits_remaining": 95
  },
  ...
]

Total: 3 pages, 15 credits (~$0.0150 USDC)

Push keywords to your CMS

If you're on WordPress, pipe the output to the REST API:

// After tagAllPages(), for each result:
async function updateWordPressTags(postId, keywords, wpApiUrl, wpToken) {
  await fetch(`${wpApiUrl}/wp/v2/posts/${postId}`, {
    method: 'PUT',
    headers: {
      'Authorization': `Bearer ${wpToken}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      meta: { _yoast_wpseo_focuskw: keywords[0], seo_keywords: keywords.join(', ') }
    }),
  });
}

For Ghost CMS:

async function updateGhostTags(postSlug, keywords, ghostApiUrl, ghostKey) {
  const tags = keywords.slice(0, 5).map(k => ({ name: k }));
  await fetch(`${ghostApiUrl}/ghost/api/admin/posts/slug/${postSlug}/`, {
    method: 'PUT',
    headers: { 'Authorization': `Ghost ${ghostKey}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ posts: [{ tags }] }),
  });
}

Scale to an entire site

For a 1,000-page blog:

// Add rate limiting to be polite to the API
import { setTimeout as sleep } from 'timers/promises';

async function tagAllPagesThrottled(pages, concurrency = 5, delayMs = 100) {
  const results = [];
  for (let i = 0; i < pages.length; i += concurrency) {
    const batch = pages.slice(i, i + concurrency);
    const batchResults = await Promise.all(batch.map(p => extractKeywords(p.text)));
    results.push(...batchResults);
    await sleep(delayMs); // 100ms between batches
    console.log(`Progress: ${Math.min(i + concurrency, pages.length)}/${pages.length}`);
  }
  return results;
}

Cost for 1,000 pages: 1,000 × 5 credits = 5,000 credits = $5 USDC.

That's less than a single monthly subscription fee, and you only pay when you run it.

Credits and top-up

Check your balance any time:

curl -H "X-API-Key: $TEXTAI_API_KEY" https://textai-api.overtek.deno.net/credits

When you need more credits, send USDC to the wallet address in the response. 1 USDC = 1,000 credits, auto-credited within seconds on Solana devnet.

Why pay-per-use beats subscriptions for this

	Pay-per-use (TextAI)	Subscription LLM
1 page	$0.005	~$0.50 (monthly min)
100 pages	$0.50	~$0.50
1,000 pages	$5.00	~$0.50–$20
Idle month	$0	$20–$100

The break-even is around 100 pages/month. Below that, pay-per-use wins. Above 10,000 pages/month, a subscription might be cheaper — but you're probably a large publication at that point.

Try it

Free credits, no credit card: https://textai-api.overtek.deno.net

Full API docs at the same URL. The keyword extraction endpoint also returns a relevance score for each keyword, useful for ranking which tags matter most for a given post.

If you build something with this, drop a comment — curious what use cases people find for bulk keyword extraction.

No subscriptions, no credit cards: how I built an API that charges $0.001 per request in USDC

Sébastien LOPEZ — Mon, 06 Apr 2026 06:03:36 +0000

I hate SaaS billing. Not as a customer — I get why subscriptions exist. But as a developer building a small tool that processes text, I couldn't justify charging someone $9/month for something they might use twice a week for 10 requests.

So I asked: what if users just paid per request — like $0.001 each — and never had to enter a credit card?

That's how TextAI API was born.

The problem with traditional API billing

Every API billing setup I looked at had the same friction:

Stripe integration (minimum $0.50 charge, fraud protection, KYC for payouts)
Monthly subscription tiers that don't match actual usage
Users need to "trust" you with their card before seeing if the product works

For a niche text processing API (summarization, keywords, translation), this friction kills conversions. The person who wants to summarize 500 blog posts doesn't want a subscription — they want to run a script once and pay 50 cents.

Why Solana + USDC

I chose Solana for three reasons:

1. Transaction fees are essentially free
Solana fees are ~$0.00025. If my API call costs $0.001, I can't use Ethereum (fees often exceed the value). Solana makes micropayments viable.

2. USDC is stable and widely held
I'm not asking users to speculate on SOL. They hold USDC in their Phantom wallet. It's like digital dollars that transfer in 400ms.

3. No intermediary
There's no payment processor taking 2.9% + $0.30. The transfer is wallet-to-wallet. I receive exactly what the user sends.

How the architecture works

Here's the payment flow:

1. User calls POST /keys/create → gets 100 free credits
2. When credits hit 0, user calls POST /keys/topup
   { wallet: "their_solana_address", amount_usdc: 1.0 }
   → API returns a payment address + expected amount
3. User sends USDC on Solana devnet to that address
4. API detects the transaction (polling via Solana RPC)
5. Credits are added: $1 USDC = 1000 credits = 1000 API calls

The key innovation: no account creation, no email, no password. The wallet address IS the identity.

What $1 gets you

Operation	Credits	Cost
Summarize text	1	$0.001
Extract keywords	1	$0.001
Translate text	1	$0.001
Detect language	1	$0.001

Process 1,000 documents for $1. Compare that to OpenAI's pricing where 1,000 summaries might cost $3–10 depending on text length.

Quick start (3 lines)

# Get a free API key (100 credits, no signup)
curl -X POST https://textai-api.overtek.deno.net/keys/create

# Use it
curl -X POST https://textai-api.overtek.deno.net/summarize \
  -H "X-API-Key: your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"text": "Your long article here...", "max_length": 150}'

The tradeoffs I accepted

Devnet only (for now): The current deployment uses Solana devnet USDC. Real payments will go live after I validate the model. Devnet lets real developers test without risk.

No fiat on-ramp: Users need a Phantom wallet and some USDC. This is a feature, not a bug — the target user is already a crypto-native developer.

No refunds: It's $0.001 per call. The operational overhead of a refund system doesn't make sense at this price point.

What surprised me

Building this was faster than I expected. The hardest part wasn't Solana — it was figuring out how to poll for transaction confirmation without hammering the RPC endpoint. A simple polling loop with exponential backoff solved it.

The second surprise: early users preferred the wallet auth. No forgot-password flows, no email verification, no GDPR consent forms. Just generate a key and go.

Try it

API: https://textai-api.overtek.deno.net

Docs: https://github.com/mokchou/textai-api

PH launch: Tomorrow (April 7) — would love your support 🚀

If you're building something with text processing at scale and $9/month subscriptions feel wrong for your use case, this might be for you.

Questions? Drop them below. I'm especially curious if there are Solana devs here who've built similar micropayment systems — would love to compare notes.

Process 1,000 articles for $1: Python content pipeline with pay-per-use AI

Sébastien LOPEZ — Mon, 06 Apr 2026 05:10:44 +0000

Most AI text APIs charge you a flat monthly fee — $50-500/month — whether you process 10 documents or 10,000. If you're building a content pipeline or a side project with unpredictable volume, that's a terrible deal.

I built TextAI API to solve this: pay-per-use text processing with USDC micropayments on Solana. You only pay when you use it. 1 USDC = 1,000 credits. No monthly commitment.

What can it do?

Three endpoints:

Summarize text (10 credits per call)
Extract keywords (5 credits per call)
Translate text to any language (15 credits per call)

A real content pipeline: 1,000 articles for < $1

Let's say you have 1,000 blog posts and you want to auto-generate summaries and extract keywords for SEO. Here's exactly what it costs:

Operation	Count	Credits	Cost at 1 USDC/1000 credits
Summarize	1,000	10,000	$1.00 (1 USDC)
Keywords	1,000	5,000	$0.50 (0.5 USDC)
Total	2,000 calls	15,000	$1.50

Compare that to OpenAI or Cohere monthly plans — you'd be paying for 1,000x more capacity than you need.

The Python code

Step 1: Get your API key (100 free credits, no credit card)

curl -X POST https://textai-api.overtek.deno.net/keys/create
# {"apiKey":"sk_...","credits":100,"demo":true}

Step 2: Process your articles

import requests
import json

API_KEY = "sk_your_key_here"
BASE_URL = "https://textai-api.overtek.deno.net"

def summarize(text):
    r = requests.post(f"{BASE_URL}/summarize",
        headers={"X-API-Key": API_KEY},
        json={"text": text}
    )
    return r.json()["summary"]

def extract_keywords(text):
    r = requests.post(f"{BASE_URL}/keywords",
        headers={"X-API-Key": API_KEY},
        json={"text": text}
    )
    return r.json()["keywords"]

# Process a batch of articles
articles = [
    "Your long blog post content here...",
    # ... more articles
]

results = []
for article in articles:
    results.append({
        "summary": summarize(article),
        "keywords": extract_keywords(article),
    })

print(json.dumps(results, indent=2))

Step 3: When you need more credits, top up with USDC

# Check your balance first
curl https://textai-api.overtek.deno.net/keys/info \
  -H "X-API-Key: sk_your_key_here"
# {"credits": 45, "totalUsed": 55}

# Top up: 1 USDC = 1,000 credits (Solana devnet)
# Instructions at: https://textai-api.overtek.deno.net

Async batch processing

For large batches, use async to maximize throughput:

import asyncio
import aiohttp

async def process_article(session, article, semaphore):
    async with semaphore:
        async with session.post(
            "https://textai-api.overtek.deno.net/summarize",
            headers={"X-API-Key": API_KEY},
            json={"text": article}
        ) as resp:
            data = await resp.json()
            return data["summary"]

async def process_batch(articles, concurrency=10):
    semaphore = asyncio.Semaphore(concurrency)
    async with aiohttp.ClientSession() as session:
        tasks = [process_article(session, a, semaphore) for a in articles]
        return await asyncio.gather(*tasks)

# Process 1,000 articles with 10 concurrent requests
summaries = asyncio.run(process_batch(articles, concurrency=10))

With 10 concurrent requests, you can process 1,000 articles in minutes, not hours.

Why USDC micropayments?

Traditional API billing requires a credit card, monthly billing cycles, and minimum charges. USDC on Solana enables:

Instant settlement — credits appear immediately after payment
Tiny amounts — you can top up $0.50 at a time
No chargebacks — transactions are final
Programmable — easy to automate top-ups in your pipeline

Translation: multilingual pipelines

The translate endpoint handles any language pair:

def translate(text, target_lang="fr"):
    r = requests.post(f"{BASE_URL}/translate",
        headers={"X-API-Key": API_KEY},
        json={"text": text, "targetLang": target_lang}
    )
    return r.json()["translation"]

# Translate 100 articles to French for $0.15
for article in articles[:100]:
    french_version = translate(article, "fr")

15 credits per translation × 100 articles = 1,500 credits = $0.15.

Try it now: https://textai-api.overtek.deno.net — 100 free credits, no credit card required.

Launching on Product Hunt tomorrow if you want to follow along!

Pay-per-use text AI API with USDC micropayments on Solana

Sébastien LOPEZ — Mon, 06 Apr 2026 00:54:34 +0000

I built a text processing API that charges per request using USDC on Solana — no subscription, no monthly fee, just pay for what you use.

API: https://textai-api.overtek.deno.net

Why pay-per-use?

Most text AI APIs force you into a monthly plan. If you're building a side project or running occasional batch jobs, you're paying for unused capacity. Pay-per-use makes more sense for sporadic workloads.

The USDC angle came from wanting a payment model that works globally without credit cards, chargebacks, or country restrictions. Solana's fees are negligible (~$0.00025/tx).

Pricing

1 USDC = 1,000 credits
Summarize: 10 credits/call
Keywords: 5 credits/call
Translate: 15 credits/call

Quick start (free demo credits included)

# Create API key — get 100 free demo credits
curl -X POST https://textai-api.overtek.deno.net/keys/create

# Summarize text
curl -X POST https://textai-api.overtek.deno.net/summarize \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Your long text here...", "max_sentences": 2}'

# Extract keywords
curl -X POST https://textai-api.overtek.deno.net/keywords \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Your text here..."}'

# Translate (EN→FR example)
curl -X POST https://textai-api.overtek.deno.net/translate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world", "targetLang": "fr"}'

Buy credits with USDC

# Request Solana deposit address
curl -X POST https://textai-api.overtek.deno.net/credits/buy \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"usdc_amount": 1}'
# Returns a Solana wallet address — send USDC there, then confirm with your tx signature

Full demo script

Complete bash walkthrough on GitHub Gist: https://gist.github.com/mokchou/6643f93ff59501f93e2e26c0db4374d1

Launching on Product Hunt tomorrow — happy to answer any questions about the architecture (it runs on Deno Deploy).

Launching on Product Hunt on April 7th: https://www.producthunt.com/products/textai-api — upvotes appreciated!

TextAI API: Pay-per-use Text Intelligence with USDC Payments on Solana

Sébastien LOPEZ — Sun, 05 Apr 2026 17:30:14 +0000

I built a small text-processing API that charges in USDC on Solana instead of monthly subscriptions. Here's the idea and how to use it.

What it does

TextAI API exposes three endpoints:

/summarize — condenses long text into a short summary (10 credits)
/keywords — extracts key topics from text (5 credits)
/translate — translates text to a target language (15 credits)

Base URL: https://textai-api.overtek.deno.net

⚠️ This URL is a temporary tunnel while we finalize permanent hosting. It will be updated soon.

Quick start (no wallet needed)

1. Create a free API key — includes 100 demo credits (~10 summarize calls):

curl -X POST https://textai-api.overtek.deno.net/keys/create

Returns:

{"apiKey":"sk_...","credits":100,"demo":true,"message":"100 free demo credits included"}

2. Summarize text (10 credits):

curl -X POST https://textai-api.overtek.deno.net/summarize \
  -H "Authorization: Bearer sk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Your long article or document text goes here...", "maxSentences": 3}'

3. Extract keywords (5 credits):

curl -X POST https://textai-api.overtek.deno.net/keywords \
  -H "Authorization: Bearer sk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Your text here", "count": 5}'

4. Translate text (15 credits):

curl -X POST https://textai-api.overtek.deno.net/translate \
  -H "Authorization: Bearer sk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world", "targetLang": "fr"}'

5. Check your balance:

curl https://textai-api.overtek.deno.net/credits/balance \
  -H "Authorization: Bearer sk_YOUR_KEY"

Pay-per-use with USDC (for production use)

When you run out of demo credits, top up with USDC on Solana devnet:

# Get a wallet address to send USDC to
curl -X POST https://textai-api.overtek.deno.net/credits/buy \
  -H "Authorization: Bearer sk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"usdcAmount": 1}'

Send 1 USDC to the returned address on Solana devnet, then confirm:

curl -X POST https://textai-api.overtek.deno.net/credits/confirm \
  -H "Authorization: Bearer sk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"txSignature": "YOUR_TX_SIGNATURE"}'

1 USDC = 1,000 credits. At 10 credits per summarize call, that's 100 calls for $1.

Pricing

Operation	Credits	Approx. cost at 1 USDC/1000 credits
Summarize	10	$0.001
Keywords	5	$0.0005
Translate	15	$0.0015

Why crypto payments?

No credit card friction — demo credits, no signup required
True pay-per-use — no monthly commitment, pay only for calls
Programmatic — bots and smart contracts can pay autonomously
Global — no payment processor restrictions

Use cases

Summarize articles for newsletters
Extract SEO keywords from blog posts
Auto-translate product descriptions for international stores
Tag and classify content in a CMS
Process customer support tickets

Current status

Early-stage API on Solana devnet. Looking for developers who want to integrate text processing without recurring billing.

Drop a comment or open an issue if you want the OpenAPI spec or want to discuss use cases. 🚀