DEV Community: Fred Santos

Essential APIs for Building an AI Agent in 2025

Fred Santos — Tue, 31 Mar 2026 16:00:06 +0000

Essential APIs for Building an AI Agent in 2025

The LLM is only the brain of your AI agent. The real capability comes from the tools it can call — the APIs that let it perceive the world, act in it, and remember what it learned.

In 2025, a production AI agent typically needs at least 6 categories of external capabilities. This guide walks through each one, with the specific APIs most developers are using.

What an AI Agent Actually Needs

Beyond the LLM (GPT-4, Claude, Gemini), a capable agent needs:

Web access — search + scrape to get current information
Document processing — PDFs, images, OCR
Communication — email, WhatsApp, notifications
Memory/storage — vector embeddings, key-value state
Media generation — images, audio, QR codes
Structured data access — APIs, databases, calculators

The challenge: most of these require separate API accounts, authentication, rate limits, and integration work. A toolkit API like IteraTools consolidates many of these into one.

Capability Matrix: What You Need and Options

1. Web Search + Scraping

API	Use Case	Price
IteraTools `/search`	Google-like results + scraping	~$0.002/req
Brave Search API	Structured search results	$3/1K queries
Serper	Google results JSON	$1/1K queries
IteraTools `/scrape`	Full page content	~$0.002/page

2. Document Processing

API	Use Case	Price
IteraTools `/pdf/extract`	PDF to text/markdown	~$0.005/page
IteraTools `/image/ocr`	Image text extraction	~$0.002/img
LlamaParse	Advanced PDF parsing	$0.003/page

3. Communication & Notifications

API	Use Case	Price
IteraTools `/whatsapp/send`	WhatsApp messages	~$0.005/msg
SendGrid	Email	$0.001/email
Twilio SMS	SMS	$0.0079/msg

4. Memory & Embeddings

API	Use Case	Price
IteraTools `/embeddings`	Text → vectors	~$0.0001/1K tokens
IteraTools `/memory`	Key-value agent memory	~$0.001/req
OpenAI Embeddings	text-embedding-3-small	$0.02/1M tokens
Pinecone	Vector storage	$0.08/1M vectors

5. Media Generation

API	Use Case	Price
IteraTools `/image/generate`	AI image generation	~$0.003/img
IteraTools `/tts`	Text to speech	~$0.001/req
IteraTools `/qrcode`	QR code generation	~$0.001/code

Building an Agent with IteraTools as the Toolkit

IteraTools provides 64+ endpoints that cover most of the non-LLM capabilities an agent needs — all under one API key. Here's how a research agent might use it:

# 1. Search the web
curl -X POST https://api.iteratools.com/v1/search \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "latest AI agent frameworks 2025", "limit": 5}'

# 2. Scrape the most relevant result
curl -X POST https://api.iteratools.com/v1/scrape \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://...", "output": "markdown"}'

# 3. Store embeddings for memory
curl -X POST https://api.iteratools.com/v1/embeddings \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "...article content...", "store": true, "namespace": "research"}'

# 4. Send summary via WhatsApp
curl -X POST https://api.iteratools.com/v1/whatsapp/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "+5511999999999", "message": "Research summary: ..."}'

Complete Python Agent Example

import requests
import os
from openai import OpenAI

ITERATOOLS_KEY = os.environ["ITERATOOLS_KEY"]
OPENAI_KEY = os.environ["OPENAI_API_KEY"]

it = requests.Session()
it.headers.update({"Authorization": f"Bearer {ITERATOOLS_KEY}"})
BASE = "https://api.iteratools.com/v1"
oai = OpenAI(api_key=OPENAI_KEY)

# ─── Tool Functions ───────────────────────────────────────────

def search_web(query: str, limit: int = 5) -> list[dict]:
    r = it.post(f"{BASE}/search", json={"query": query, "limit": limit})
    return r.json()["results"]

def scrape_page(url: str) -> str:
    r = it.post(f"{BASE}/scrape", json={"url": url, "output": "markdown"})
    return r.json().get("markdown", "")

def extract_pdf(url: str) -> str:
    r = it.post(f"{BASE}/pdf/extract", json={"url": url, "output": "text"})
    return r.json().get("text", "")

def store_memory(key: str, value: str) -> None:
    it.post(f"{BASE}/memory/set", json={"key": key, "value": value})

def recall_memory(key: str) -> str:
    r = it.get(f"{BASE}/memory/get", params={"key": key})
    return r.json().get("value", "")

def send_whatsapp(phone: str, message: str) -> dict:
    r = it.post(f"{BASE}/whatsapp/send", json={"to": phone, "message": message})
    return r.json()

def generate_image(prompt: str) -> str:
    r = it.post(f"{BASE}/image/generate", json={"prompt": prompt, "model": "flux"})
    return r.json()["url"]

# ─── Tool Definitions for LLM ────────────────────────────────

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Search the web for current information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "limit": {"type": "integer", "default": 5}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "scrape_page",
            "description": "Get full content of a webpage as markdown",
            "parameters": {
                "type": "object",
                "properties": {"url": {"type": "string"}},
                "required": ["url"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "send_whatsapp",
            "description": "Send a WhatsApp message to a phone number",
            "parameters": {
                "type": "object",
                "properties": {
                    "phone": {"type": "string", "description": "Phone with country code: +5511..."},
                    "message": {"type": "string"}
                },
                "required": ["phone", "message"]
            }
        }
    }
]

TOOL_MAP = {
    "search_web": search_web,
    "scrape_page": scrape_page,
    "send_whatsapp": send_whatsapp,
}

# ─── Agent Loop ───────────────────────────────────────────────

def run_agent(task: str) -> str:
    """Run an agent that can search, scrape, and send WhatsApp."""
    import json

    messages = [
        {"role": "system", "content": "You are a research assistant. Use your tools to complete tasks."},
        {"role": "user", "content": task}
    ]

    while True:
        response = oai.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=TOOLS,
            tool_choice="auto"
        )

        msg = response.choices[0].message
        messages.append(msg)

        if not msg.tool_calls:
            return msg.content

        for call in msg.tool_calls:
            fn_name = call.function.name
            args = json.loads(call.function.arguments)

            print(f"  → {fn_name}({args})")
            result = TOOL_MAP[fn_name](**args)

            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(result)
            })

if __name__ == "__main__":
    result = run_agent(
        "Search for the top 3 AI agent frameworks released in 2025, "
        "summarize each in 2 sentences, and tell me which is most popular."
    )
    print("\n=== Agent Result ===")
    print(result)

Architecture Tip: One API Key to Rule Them All

The main advantage of a toolkit approach: you don't need to manage 6+ separate API keys, rate limits, and billing accounts. IteraTools covers:

✅ Web search + scraping + crawling
✅ PDF, image, OCR processing
✅ WhatsApp messaging
✅ Text-to-speech + transcription
✅ Memory + embeddings
✅ Image generation + manipulation
✅ QR codes, URL shortener, email validation, weather, crypto prices

That's most of what a general-purpose agent needs in a single API with credit-based pricing.

Conclusion

Building a capable AI agent in 2025 is more about tool integration than LLM selection. The LLM is a commodity — the differentiator is how many useful actions your agent can take.

IteraTools solves the "tooling tax" problem: instead of 10 API accounts, one key gives you 64+ capabilities with a single unified billing model. Start your agent at api.iteratools.com.

How to Generate QR Codes via REST API (Examples in 5 Languages)

Fred Santos — Mon, 30 Mar 2026 16:01:25 +0000

How to Generate QR Codes via REST API (Examples in 5 Languages)

QR codes are everywhere — restaurant menus, payment links, event check-ins, product packaging. Generating them via API is simpler than installing a library in every language and environment you work with.

This tutorial shows how to generate QR codes using IteraTools' QR endpoint, with examples in Python, JavaScript, PHP, Go, and Ruby.

Why Use a QR Code API Instead of a Library?

No dependencies: No qrcode, python-qrcode, node-qrcode, or similar library to install and maintain.
Consistent output: Same quality and format across all your systems.
Serverless friendly: Works in Lambda, Cloud Functions, Edge workers — anywhere HTTP works.
Customization without code: Colors, logo overlays, error correction levels via parameters.
One less thing to update: Library updates, security patches, dependency conflicts — not your problem.

Comparison Table

Approach	Setup	Customization	Server Needed	Cost
IteraTools API	API key	High (colors, logos)	No	~$0.001/code
python-qrcode	pip install	Medium	Yes (Python env)	Free
node-qrcode	npm install	Medium	Yes (Node env)	Free
GoQR.me API	None	Low	No	Free (limited)
QR Server API	None	Low	No	Free (watermark)

For most production apps, paying fractions of a cent per QR code is cheaper than managing library dependencies.

Generate a QR Code — curl

curl -X POST https://api.iteratools.com/v1/qrcode \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "data": "https://iteratools.com",
    "size": 300,
    "format": "png"
  }' \
  --output qrcode.png

With custom colors and logo:

curl -X POST https://api.iteratools.com/v1/qrcode \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "data": "https://iteratools.com",
    "size": 400,
    "format": "png",
    "foreground": "#1a1a2e",
    "background": "#ffffff",
    "error_correction": "H"
  }'

Response (when using return_url: true):

{
  "url": "https://cdn.iteratools.com/qrcodes/abc123.png",
  "size": 400,
  "format": "png",
  "credits_used": 1
}

Examples in 5 Languages

Python

import requests
from pathlib import Path

API_KEY = "your_api_key_here"

def generate_qrcode(data: str, output_file: str = "qr.png", size: int = 300) -> str:
    response = requests.post(
        "https://api.iteratools.com/v1/qrcode",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "data": data,
            "size": size,
            "format": "png",
            "return_url": True
        }
    )
    response.raise_for_status()
    result = response.json()

    # Download PNG
    img = requests.get(result["url"])
    Path(output_file).write_bytes(img.content)
    print(f"QR saved: {output_file}")
    return result["url"]

# Generate QR for a payment link
generate_qrcode("https://pay.example.com/invoice/12345", "payment_qr.png")

JavaScript (Node.js / fetch)

const fs = require('fs');

async function generateQRCode(data, outputFile = 'qr.png', size = 300) {
  const response = await fetch('https://api.iteratools.com/v1/qrcode', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.ITERATOOLS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ data, size, format: 'png', return_url: true })
  });

  if (!response.ok) {
    throw new Error(`API error: ${response.status}`);
  }

  const result = await response.json();

  // Download and save
  const imgResponse = await fetch(result.url);
  const buffer = Buffer.from(await imgResponse.arrayBuffer());
  fs.writeFileSync(outputFile, buffer);

  console.log(`QR saved: ${outputFile}`);
  return result.url;
}

// Usage
generateQRCode('https://example.com/menu', 'menu_qr.png', 400)
  .then(url => console.log('URL:', url))
  .catch(console.error);

PHP

<?php

function generateQRCode(string $data, string $outputFile = 'qr.png', int $size = 300): string {
    $apiKey = getenv('ITERATOOLS_API_KEY');

    $payload = json_encode([
        'data'       => $data,
        'size'       => $size,
        'format'     => 'png',
        'return_url' => true,
    ]);

    $ch = curl_init('https://api.iteratools.com/v1/qrcode');
    curl_setopt_array($ch, [
        CURLOPT_POST           => true,
        CURLOPT_POSTFIELDS     => $payload,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => [
            "Authorization: Bearer $apiKey",
            'Content-Type: application/json',
        ],
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    $result = json_decode($response, true);
    $imageData = file_get_contents($result['url']);
    file_put_contents($outputFile, $imageData);

    echo "QR saved: $outputFile\n";
    return $result['url'];
}

// Generate QR for WiFi credentials
generateQRCode('WIFI:T:WPA;S:MyNetwork;P:MyPassword;;', 'wifi_qr.png');

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
)

const apiKey = "your_api_key_here"

type QRRequest struct {
    Data      string `json:"data"`
    Size      int    `json:"size"`
    Format    string `json:"format"`
    ReturnURL bool   `json:"return_url"`
}

type QRResponse struct {
    URL         string `json:"url"`
    CreditsUsed int    `json:"credits_used"`
}

func generateQRCode(data, outputFile string, size int) (string, error) {
    payload, _ := json.Marshal(QRRequest{
        Data: data, Size: size, Format: "png", ReturnURL: true,
    })

    req, _ := http.NewRequest("POST", "https://api.iteratools.com/v1/qrcode",
        bytes.NewBuffer(payload))
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    var result QRResponse
    json.NewDecoder(resp.Body).Decode(&result)

    // Download image
    imgResp, _ := http.Get(result.URL)
    defer imgResp.Body.Close()
    imgData, _ := io.ReadAll(imgResp.Body)
    os.WriteFile(outputFile, imgData, 0644)

    fmt.Printf("QR saved: %s\n", outputFile)
    return result.URL, nil
}

func main() {
    generateQRCode("https://example.com/product/42", "product_qr.png", 350)
}

Ruby

require 'net/http'
require 'json'
require 'uri'
require 'open-uri'

API_KEY = ENV['ITERATOOLS_API_KEY'] || 'your_api_key_here'

def generate_qrcode(data, output_file: 'qr.png', size: 300)
  uri = URI('https://api.iteratools.com/v1/qrcode')

  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri.path)
  request['Authorization'] = "Bearer #{API_KEY}"
  request['Content-Type'] = 'application/json'
  request.body = { data: data, size: size, format: 'png', return_url: true }.to_json

  response = http.request(request)
  result = JSON.parse(response.body)

  # Download image
  URI.open(result['url']) do |img|
    File.binwrite(output_file, img.read)
  end

  puts "QR saved: #{output_file}"
  result['url']
end

# Generate QR for business card vCard
vcard = "BEGIN:VCARD\nVERSION:3.0\nFN:John Doe\nTEL:+15551234567\nEND:VCARD"
generate_qrcode(vcard, output_file: 'business_card_qr.png', size: 350)

Common QR Code Use Cases

Payment links: Generate per-transaction QR codes for checkout pages
Restaurant menus: Unique QR per table or menu version
WiFi credentials: WIFI:T:WPA;S:NetworkName;P:Password;;
vCards: Encode contact information in QR for business cards
Event check-in: Unique QR per ticket/attendee
Product tracking: QR codes that link to warranty/support pages

Conclusion

Generating QR codes via REST API is simpler than managing a library in every language and runtime you work with. IteraTools provides a clean endpoint at ~$0.001/code — practically free for most use cases, with no library installs or dependency management.

Since it's the same API as your image processing, scraping, and PDF tools, there's zero additional setup.

→ Generate your first QR at api.iteratools.com

How to Convert PDF to Text via API (No poppler, No pdfminer, No Local Libraries)

Fred Santos — Fri, 27 Mar 2026 16:07:14 +0000

How to Convert PDF to Text via API (No poppler, No pdfminer, No Local Libraries)

Converting PDFs to text locally means installing poppler-utils, pdfminer, or PyMuPDF — and then handling edge cases: scanned PDFs needing OCR, multi-column layouts, embedded images, password-protected files. It's a rabbit hole.

For most applications — especially RAG pipelines, document processing workflows, and data extraction — a PDF API is the cleaner solution. Send the file, get back structured text.

What to Consider When Choosing a PDF API

Text extraction vs OCR: Does it handle scanned PDFs (image-based)?
Structure preservation: Tables, headers, lists — does it maintain them?
Output format: Plain text, markdown, or JSON with page/section structure?
File size limits: PDFs can be large; check limits.
Language support: OCR quality across languages varies.
Price: Per page or per document?

Comparison Table

Tool	Price	OCR	Output Format	File Limit	Limitations
IteraTools	~$0.005/page (credits)	Yes	Text, markdown	50MB	Complex tables may lose structure
Adobe Extract API	$0.15/page	Yes	JSON (rich)	100MB	Expensive, complex auth
AWS Textract	$0.0015/page	Yes	JSON	500MB	AWS ecosystem required
LlamaParse	$0.003/page	Yes	Markdown	50MB	LlamaIndex ecosystem
Unstructured.io	$0.002/page	Yes	JSON	Varies	Complex output schema

IteraTools PDF Extraction — How to Use It

Extract text from a PDF URL:

curl -X POST https://api.iteratools.com/v1/pdf/extract \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/annual_report.pdf",
    "output": "markdown"
  }'

Upload a local PDF:

curl -X POST https://api.iteratools.com/v1/pdf/extract \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@contract.pdf" \
  -F "output=text" \
  -F "ocr=true"

Response:

{
  "text": "# Annual Report 2024\n\n## Executive Summary\n\nThis year marked a significant...",
  "pages": 42,
  "format": "markdown",
  "has_ocr": false,
  "credits_used": 21
}

Specify page range:

curl -X POST https://api.iteratools.com/v1/pdf/extract \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/long_report.pdf",
    "pages": "1-10",
    "output": "markdown"
  }'

Complete Python Example

import requests
from pathlib import Path
import json

API_KEY = "your_api_key_here"
BASE_URL = "https://api.iteratools.com/v1"

def pdf_to_text(pdf_path: str = None, pdf_url: str = None,
                output_format: str = "markdown", ocr: bool = False) -> dict:
    """Extract text from PDF file or URL."""
    headers = {"Authorization": f"Bearer {API_KEY}"}

    if pdf_path:
        with open(pdf_path, "rb") as f:
            response = requests.post(
                f"{BASE_URL}/pdf/extract",
                headers=headers,
                files={"file": (Path(pdf_path).name, f)},
                data={"output": output_format, "ocr": str(ocr).lower()}
            )
    elif pdf_url:
        response = requests.post(
            f"{BASE_URL}/pdf/extract",
            headers=headers,
            json={"url": pdf_url, "output": output_format, "ocr": ocr}
        )
    else:
        raise ValueError("Provide either pdf_path or pdf_url")

    response.raise_for_status()
    return response.json()

def pdf_to_rag_chunks(pdf_path: str, chunk_size: int = 1000) -> list[dict]:
    """Extract PDF and split into chunks for RAG/embeddings."""
    result = pdf_to_text(pdf_path=pdf_path, output_format="text")
    text = result["text"]

    # Split into chunks with overlap
    chunks = []
    words = text.split()
    chunk_words = chunk_size // 6  # Rough word count per chunk

    for i in range(0, len(words), chunk_words - 50):  # 50-word overlap
        chunk = " ".join(words[i:i + chunk_words])
        if chunk.strip():
            chunks.append({
                "content": chunk,
                "index": len(chunks),
                "source": pdf_path
            })

    return chunks

def process_invoice(pdf_path: str) -> dict:
    """Extract structured data from an invoice PDF."""
    result = pdf_to_text(pdf_path=pdf_path, output_format="text", ocr=True)
    text = result["text"]

    # Pass to LLM for structured extraction (example with OpenAI)
    # In practice, you'd use your preferred LLM here
    return {
        "raw_text": text,
        "pages": result["pages"],
        "ready_for_llm": True
    }

def batch_process_pdfs(pdf_dir: str, output_dir: str) -> list[dict]:
    """Convert all PDFs in a directory to text files."""
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    results = []

    pdf_files = list(Path(pdf_dir).glob("*.pdf"))
    print(f"Processing {len(pdf_files)} PDFs...")

    for pdf_file in pdf_files:
        print(f"  Converting {pdf_file.name}...")
        try:
            result = pdf_to_text(pdf_path=str(pdf_file), output_format="markdown")

            # Save as .md file
            output_file = Path(output_dir) / f"{pdf_file.stem}.md"
            output_file.write_text(result["text"])

            results.append({
                "source": str(pdf_file),
                "output": str(output_file),
                "pages": result["pages"],
                "success": True
            })
            print(f"    ✓ {result['pages']} pages → {output_file.name}")

        except Exception as e:
            print(f"    ✗ Error: {e}")
            results.append({
                "source": str(pdf_file),
                "success": False,
                "error": str(e)
            })

    return results

if __name__ == "__main__":
    # Simple extraction
    result = pdf_to_text(
        pdf_url="https://arxiv.org/pdf/2303.08774.pdf",
        output_format="markdown"
    )
    print(f"Extracted {result['pages']} pages")
    print(result["text"][:1000])

    # For RAG pipeline
    chunks = pdf_to_rag_chunks("research_paper.pdf", chunk_size=800)
    print(f"\nCreated {len(chunks)} chunks for embedding")

    # Save chunks for vector DB ingestion
    with open("chunks.json", "w") as f:
        json.dump(chunks, f, indent=2)

Handling Scanned PDFs

Scanned PDFs (images inside a PDF container) require OCR. Set "ocr": true:

curl -X POST https://api.iteratools.com/v1/pdf/extract \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/scanned_contract.pdf",
    "ocr": true,
    "language": "en"
  }'

OCR quality depends on scan quality. For critical documents (legal, financial), verify results against the original.

Conclusion

For developers building document processing pipelines, RAG knowledge bases, or invoice extraction workflows, a PDF API eliminates the entire poppler/pdfminer setup and handles edge cases like scanned PDFs automatically.

IteraTools provides PDF extraction as part of a broader toolkit — you can extract, chunk, and immediately store embeddings all within the same API ecosystem, at a fraction of the cost of Adobe Extract or AWS Textract.

→ Start extracting PDFs at api.iteratools.com

How to Remove Image Backgrounds via REST API in 2 Lines of Code

Fred Santos — Thu, 26 Mar 2026 16:01:57 +0000

How to Remove Image Backgrounds via REST API in 2 Lines of Code

Background removal used to require Photoshop, GIMP scripts, or local Python environments with rembg and its model files (~170MB). Today you can do it with a single HTTP request.

This tutorial shows how to remove backgrounds from images using IteraTools' rembg endpoint — no Python environment, no model downloads, no GPU required.

What to Consider When Choosing a Background Removal API

Quality on complex edges: Hair, fur, and transparent objects are the real test.
Output format: Must return transparent PNG (not JPEG which doesn't support transparency).
Input flexibility: Accepts URLs or file uploads.
Speed: Batch processing speed for product catalogs matters.
Price at scale: Per-image pricing adds up fast for e-commerce use cases.

Comparison Table

Tool	Price	Quality	Input Types	Output
IteraTools	~$0.002/image (credits)	Good (rembg)	URL, file upload	Transparent PNG
Remove.bg	$0.20/image	Excellent	URL, file	PNG
Clipdrop	$0.10–$0.20/image	Very Good	File	PNG
PhotoRoom API	$0.10/image	Excellent	File	PNG
BgSub	$0.05/image	Good	File	PNG

IteraTools is 50–100x cheaper than premium providers like Remove.bg, making it viable for bulk operations. Quality is solid for most product photography use cases.

Remove Background — 2-line curl

curl -X POST https://api.iteratools.com/v1/image/rembg \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product.jpg"}' \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['url'])"

That's it. Two commands (one API call + extracting the URL), no installations.

Full response:

curl -X POST https://api.iteratools.com/v1/image/rembg \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/shoe_photo.jpg"
  }'

{
  "url": "https://cdn.iteratools.com/images/rembg/transparent_abc123.png",
  "format": "png",
  "width": 800,
  "height": 600,
  "credits_used": 2
}

Upload a local file:

curl -X POST https://api.iteratools.com/v1/image/rembg \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@product_photo.jpg"

Complete Python Example

import requests
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed

API_KEY = "your_api_key_here"
BASE_URL = "https://api.iteratools.com/v1"

def remove_background_url(image_url: str) -> str:
    """Remove background from image URL, return transparent PNG URL."""
    response = requests.post(
        f"{BASE_URL}/image/rembg",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"url": image_url}
    )
    response.raise_for_status()
    return response.json()["url"]

def remove_background_file(image_path: str, output_path: str = None) -> str:
    """Remove background from local file, save transparent PNG."""
    if output_path is None:
        p = Path(image_path)
        output_path = str(p.parent / f"{p.stem}_nobg.png")

    with open(image_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/image/rembg",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": (Path(image_path).name, f)}
        )
    response.raise_for_status()
    data = response.json()

    # Download the transparent PNG
    img_data = requests.get(data["url"])
    Path(output_path).write_bytes(img_data.content)

    return output_path

def batch_remove_backgrounds(image_paths: list[str], max_workers: int = 5) -> dict:
    """Process multiple images in parallel."""
    results = {}

    def process_one(path: str) -> tuple:
        try:
            output = remove_background_file(path)
            return path, output, None
        except Exception as e:
            return path, None, str(e)

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {executor.submit(process_one, p): p for p in image_paths}
        for future in as_completed(futures):
            input_path, output_path, error = future.result()
            if error:
                print(f"✗ {input_path}: {error}")
                results[input_path] = {"success": False, "error": error}
            else:
                print(f"✓ {input_path} → {output_path}")
                results[input_path] = {"success": True, "output": output_path}

    return results

def process_product_catalog(catalog_dir: str, output_dir: str) -> None:
    """Process all product images in a directory."""
    Path(output_dir).mkdir(parents=True, exist_ok=True)

    image_files = list(Path(catalog_dir).glob("*.jpg")) + \
                  list(Path(catalog_dir).glob("*.png")) + \
                  list(Path(catalog_dir).glob("*.jpeg"))

    print(f"Processing {len(image_files)} images...")

    for img_path in image_files:
        output_path = Path(output_dir) / f"{img_path.stem}_nobg.png"
        remove_background_file(str(img_path), str(output_path))
        print(f"  ✓ {img_path.name}")

    print(f"\nDone! Transparent PNGs saved to: {output_dir}")

if __name__ == "__main__":
    # Single image
    result_url = remove_background_url(
        "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=500"
    )
    print(f"Transparent PNG: {result_url}")

    # Local file
    output = remove_background_file("my_product.jpg")
    print(f"Saved to: {output}")

    # Batch process product catalog
    product_images = [
        "products/shoe_01.jpg",
        "products/shoe_02.jpg",
        "products/bag_01.jpg",
    ]
    results = batch_remove_backgrounds(product_images, max_workers=3)
    successful = sum(1 for r in results.values() if r["success"])
    print(f"\nProcessed: {successful}/{len(product_images)} successful")

Combine with Image Generation

One powerful pattern: generate a product image, then immediately remove its background:

# Generate → Remove Background → Resize (all via IteraTools)
def create_product_image(prompt: str) -> str:
    # 1. Generate
    gen = requests.post(
        f"{BASE_URL}/image/generate",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"prompt": prompt, "model": "flux"}
    ).json()

    # 2. Remove background
    rembg = requests.post(
        f"{BASE_URL}/image/rembg",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"url": gen["url"]}
    ).json()

    # 3. Resize to thumbnail
    thumb = requests.post(
        f"{BASE_URL}/image/resize",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"url": rembg["url"], "width": 400, "height": 400}
    ).json()

    return thumb["url"]

url = create_product_image("red leather sneaker, product photography, white background")
print(f"Product ready: {url}")

Conclusion

Background removal via REST API is one of the most practical image processing tasks to offload to a cloud service. IteraTools makes it trivially easy and affordable — especially for bulk e-commerce catalogs where premium services like Remove.bg would cost 50–100x more.

The real advantage: it's part of the same API toolkit as image generation, resizing, OCR, and more — so you can chain operations without juggling multiple API keys.

→ Try IteraTools rembg — 2¢ per image, no subscription.

How to Send WhatsApp Messages via API in Python Without Twilio

Fred Santos — Tue, 24 Mar 2026 16:00:33 +0000

How to Send WhatsApp Messages via API in Python Without Twilio

Twilio's WhatsApp API works, but it's expensive ($0.05+ per conversation), requires a complex account setup, and the sandbox is frustrating to use during development. For developers in Brazil and Latin America especially, there are better options.

This tutorial shows how to send WhatsApp messages — both template messages and free-form replies — using IteraTools' WhatsApp endpoint, with complete curl and Python examples.

What You'll Need

An IteraTools API key (get one at api.iteratools.com)
A WhatsApp number to send to (recipient must be on WhatsApp)
5 minutes

No WhatsApp Business account registration. No Meta app approval. No webhook setup for basic sending.

What to Consider When Choosing a WhatsApp API

Tool	Price	Setup Time	Template Required	Limitations
IteraTools	~$0.005/msg (credits)	Minutes	No (for replies)	Volume limits
Twilio	$0.05/conversation + msg fee	Hours/days	Yes (for outbound)	Expensive
360dialog	$50/mo + per msg	Days (BSP approval)	Yes	Complex setup
Meta Cloud API	Free (infra costs)	Days (app review)	Yes	Self-managed
Zapi / WPPConnect	~$30/mo	Hours	No	TOS gray area

Sending a Message — curl

Send a WhatsApp message via IteraTools:

curl -X POST https://api.iteratools.com/v1/whatsapp/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+5511999998888",
    "message": "Hello! Your order #1234 has been shipped and will arrive by Friday."
  }'

Response:

{
  "message_id": "wamid.abc123xyz",
  "status": "sent",
  "to": "+5511999998888",
  "credits_used": 1
}

Send a message with media:

curl -X POST https://api.iteratools.com/v1/whatsapp/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+5511999998888",
    "message": "Here is your invoice:",
    "media_url": "https://example.com/invoice_1234.pdf",
    "media_type": "document"
  }'

Receiving Replies — Webhook Setup

To receive incoming WhatsApp messages, set up a webhook endpoint in your IteraTools dashboard. Incoming messages will be POSTed to your URL:

{
  "from": "+5511999998888",
  "message": "Yes, please confirm my order.",
  "message_id": "wamid.inbound456",
  "timestamp": "2025-03-15T14:32:00Z"
}

Reply to an incoming message:

curl -X POST https://api.iteratools.com/v1/whatsapp/reply \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "message_id": "wamid.inbound456",
    "message": "Great! Your order has been confirmed. 🎉"
  }'

Complete Python Example

import requests
from flask import Flask, request, jsonify

API_KEY = "your_api_key_here"
BASE_URL = "https://api.iteratools.com/v1"

# ─────────────────────────────────────────────
# Sending Messages
# ─────────────────────────────────────────────

def send_whatsapp(to: str, message: str, media_url: str = None) -> dict:
    """Send a WhatsApp message."""
    payload = {
        "to": to,
        "message": message
    }
    if media_url:
        payload["media_url"] = media_url
        payload["media_type"] = "image"

    response = requests.post(
        f"{BASE_URL}/whatsapp/send",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json=payload
    )
    response.raise_for_status()
    return response.json()

def reply_whatsapp(message_id: str, reply_text: str) -> dict:
    """Reply to an incoming WhatsApp message."""
    response = requests.post(
        f"{BASE_URL}/whatsapp/reply",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "message_id": message_id,
            "message": reply_text
        }
    )
    response.raise_for_status()
    return response.json()

# ─────────────────────────────────────────────
# Webhook Server (to receive messages)
# ─────────────────────────────────────────────

app = Flask(__name__)

def handle_incoming_message(sender: str, text: str, message_id: str) -> str:
    """Simple keyword-based auto-reply bot."""
    text_lower = text.lower().strip()

    if any(word in text_lower for word in ["hi", "hello", "hey", "oi", "olá"]):
        return "Hello! 👋 How can I help you today?"

    elif "order" in text_lower or "pedido" in text_lower:
        return (
            "To check your order status, please reply with your order number. "
            "Example: ORDER 12345"
        )

    elif text_lower.startswith("order "):
        order_num = text_lower.replace("order ", "").strip()
        # In production, look up the order in your database
        return f"Order #{order_num}: Shipped ✅ Expected delivery: Friday, March 21"

    else:
        return (
            "I didn't understand that. Try:\n"
            "• *ORDER [number]* — check order status\n"
            "• *HELP* — see all commands"
        )

@app.route("/webhook/whatsapp", methods=["POST"])
def whatsapp_webhook():
    data = request.json

    sender = data.get("from")
    text = data.get("message", "")
    message_id = data.get("message_id")

    print(f"Incoming from {sender}: {text}")

    # Generate auto-reply
    reply_text = handle_incoming_message(sender, text, message_id)

    # Send reply
    result = reply_whatsapp(message_id, reply_text)
    print(f"Replied: {result['status']}")

    return jsonify({"status": "ok"})

# ─────────────────────────────────────────────
# Main: Bulk Send Example
# ─────────────────────────────────────────────

if __name__ == "__main__":
    # Example: Send order confirmations to a list of customers
    orders = [
        {"phone": "+5511999990001", "order": "1001", "item": "Wireless Headphones"},
        {"phone": "+5511999990002", "order": "1002", "item": "Phone Case"},
        {"phone": "+5521999990003", "order": "1003", "item": "USB-C Cable"},
    ]

    for order in orders:
        message = (
            f"Hi! Your order #{order['order']} ({order['item']}) "
            f"has been confirmed and will ship within 24 hours. "
            f"Thank you for your purchase! 🛍️"
        )
        result = send_whatsapp(order["phone"], message)
        print(f"Sent to {order['phone']}: {result['status']}")

    # Start webhook server (run in production with gunicorn)
    # app.run(port=5000, debug=True)

Sending WhatsApp Without Code (one-liner)

For quick testing:

# Send a test message right now
curl -X POST https://api.iteratools.com/v1/whatsapp/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"to": "+YOUR_NUMBER", "message": "Test from IteraTools API ✅"}'

Conclusion

Sending WhatsApp messages via API doesn't have to mean navigating Twilio's pricing or Meta's Business Manager setup. IteraTools makes it straightforward: one API key, one endpoint, pay per message with no monthly fees.

For projects already using IteraTools for scraping, PDFs, or image processing, adding WhatsApp notifications is a 5-minute addition — no new accounts needed.

→ Get started at api.iteratools.com

Cheapest Audio Transcription APIs in 2025: Whisper via API vs AssemblyAI vs Deepgram

Fred Santos — Mon, 23 Mar 2026 16:00:36 +0000

Cheapest Audio Transcription APIs in 2025: Whisper via API vs AssemblyAI vs Deepgram

Audio transcription has become a commodity — Whisper changed everything. But running Whisper locally requires a GPU (or at least a beefy CPU), and hosting it yourself adds ops overhead. The better path for most developers: use a transcription API.

This guide compares the leading audio transcription APIs by price, accuracy, language support, and developer experience.

What to Consider When Choosing a Transcription API

Price: Charged per minute of audio, per hour, or per request. Volume discounts matter.
Accuracy: Varies by language, audio quality, and domain (medical, legal, technical).
Languages: Whisper supports 99+ languages; some services only optimize for English.
Speaker diarization: Can it distinguish who's speaking?
Turnaround time: Real-time streaming vs async batch processing.
Word-level timestamps: Needed for video subtitles and caption generation.

Comparison Table

Tool	Price	Languages	Diarization	Timestamps	Base Model
IteraTools	~$0.003/min (credits)	99+ (Whisper)	No	Yes	Whisper
AssemblyAI	$0.01/min	99+	Yes	Yes	Custom
Deepgram	$0.0043/min	36	Yes	Yes	Custom
OpenAI Whisper API	$0.006/min	99+	No	Yes	Whisper
Groq Whisper	$0.002/min	99+	No	No	Whisper large-v3

IteraTools Transcription — How to Use It

Transcribe from a URL:

curl -X POST https://api.iteratools.com/v1/transcribe \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/audio/interview.mp3",
    "language": "en"
  }'

Upload a local file:

curl -X POST https://api.iteratools.com/v1/transcribe \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@recording.mp3" \
  -F "language=pt"

Response:

{
  "text": "Hello, today we're going to discuss the quarterly results...",
  "language": "en",
  "duration_seconds": 142.5,
  "words": [
    {"word": "Hello", "start": 0.0, "end": 0.4, "confidence": 0.99},
    {"word": "today", "start": 0.5, "end": 0.8, "confidence": 0.98}
  ],
  "credits_used": 5
}

Complete Python Example

import requests
from pathlib import Path

API_KEY = "your_api_key_here"
BASE_URL = "https://api.iteratools.com/v1"

def transcribe_file(audio_path: str, language: str = "en") -> dict:
    """Transcribe a local audio file."""
    with open(audio_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/transcribe",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": (Path(audio_path).name, f)},
            data={"language": language}
        )
    response.raise_for_status()
    return response.json()

def transcribe_url(audio_url: str, language: str = "en") -> dict:
    """Transcribe audio from a URL."""
    response = requests.post(
        f"{BASE_URL}/transcribe",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"url": audio_url, "language": language}
    )
    response.raise_for_status()
    return response.json()

def generate_srt(transcription: dict, output_file: str = "subtitles.srt"):
    """Generate SRT subtitle file from transcription with timestamps."""
    words = transcription.get("words", [])
    if not words:
        print("No word-level timestamps available")
        return

    # Group words into subtitle chunks (max 10 words per chunk)
    chunks = []
    chunk_words = []

    for word in words:
        chunk_words.append(word)
        if len(chunk_words) >= 10:
            chunks.append(chunk_words)
            chunk_words = []

    if chunk_words:
        chunks.append(chunk_words)

    def format_time(seconds: float) -> str:
        h = int(seconds // 3600)
        m = int((seconds % 3600) // 60)
        s = int(seconds % 60)
        ms = int((seconds % 1) * 1000)
        return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"

    with open(output_file, "w") as f:
        for i, chunk in enumerate(chunks, 1):
            start = chunk[0]["start"]
            end = chunk[-1]["end"]
            text = " ".join(w["word"] for w in chunk)
            f.write(f"{i}\n")
            f.write(f"{format_time(start)} --> {format_time(end)}\n")
            f.write(f"{text}\n\n")

    print(f"SRT saved: {output_file} ({len(chunks)} subtitle blocks)")

if __name__ == "__main__":
    # Transcribe a meeting recording
    result = transcribe_file("meeting.mp3", language="en")

    print(f"Transcript ({result['duration_seconds']:.0f}s audio):")
    print(result["text"][:500])
    print(f"\nCredits used: {result['credits_used']}")

    # Generate subtitles for a video
    result_pt = transcribe_file("video_audio.mp3", language="pt")
    generate_srt(result_pt, "video_subtitles.srt")

    # Batch process a folder of recordings
    audio_dir = Path("recordings/")
    for audio_file in audio_dir.glob("*.mp3"):
        print(f"Transcribing {audio_file.name}...")
        result = transcribe_file(str(audio_file))

        # Save transcript
        transcript_path = audio_file.with_suffix(".txt")
        transcript_path.write_text(result["text"])
        print(f"  ✓ Saved to {transcript_path}")

Accuracy Notes by Language

Whisper-based APIs (including IteraTools and OpenAI) generally excel at:

English, Spanish, French, German, Japanese, Portuguese — very high accuracy
Mandarin, Arabic, Hindi — good accuracy
Less common languages — variable; test with your specific language

AssemblyAI and Deepgram use custom models optimized for English, often with better accuracy for business audio, accents, and domain-specific terminology.

Conclusion

For developers who need transcription at reasonable cost with solid multi-language support, IteraTools provides a great balance: Whisper-quality transcription at ~$0.003/min, with word timestamps, and no subscription required. It's also part of a broader API toolkit — you can immediately pass the transcript to IteraTools' text/embedding/search endpoints.

For English-only applications that need speaker diarization, AssemblyAI or Deepgram are worth the premium.

→ Try IteraTools transcription — 99+ languages, pay per use.

Give Your AI Agent a Browser: Web Automation via API with IteraTools

Fred Santos — Sun, 22 Mar 2026 20:14:41 +0000

Give Your AI Agent a Browser: Web Automation via API with IteraTools

Published: [to be published on dev.to — login with GitHub account]

One of the most requested features for AI agents is the ability to actually do things on the web — fill forms, click buttons, extract data from JavaScript-heavy pages, log in to services. Until now, setting up a headless browser was a pain: install Playwright or Puppeteer, manage dependencies, handle concurrency, deal with sandboxing.

IteraTools /browser/act flips this: you send a JSON list of actions, we run a real Chromium browser server-side, and return results. One API call, no browser setup.

How It Works

The endpoint accepts an actions array where each action has a type and relevant params:

curl -X POST https://api.iteratools.com/browser/act \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "actions": [
      { "type": "navigate", "url": "https://news.ycombinator.com" },
      { "type": "waitForSelector", "selector": ".titleline" },
      { "type": "evaluate",
        "script": "Array.from(document.querySelectorAll(\".titleline a\")).slice(0,5).map(a=>({title: "a.textContent,url:a.href}))\" }"
    ]
  }'

Response:

{
  "success": true,
  "steps": 3,
  "duration_ms": 847,
  "results": [
    {
      "step": 3,
      "type": "evaluate",
      "value": [
        {"title": "Show HN: I built an MCP server for browser automation", "url": "https://..."},
        ...
      ]
    }
  ]
}

Supported Actions

Action	What it does
`navigate`	Go to a URL
`click`	Click an element by CSS selector
`type`	Type text into an input
`press`	Press a keyboard key (Enter, Tab, Escape…)
`wait`	Wait N milliseconds
`waitForSelector`	Wait until an element appears
`extract`	Get text/HTML from a selector
`screenshot`	Capture a PNG screenshot (base64)
`evaluate`	Run JavaScript in the page
`select`	Choose an option in a `<select>`

Up to 20 actions per request, 10 seconds per action.

Real-World Example: AI Agent That Monitors Prices

Here's a Python agent that uses IteraTools to check a product price daily:

import requests

ITERATOOLS_KEY = "it-XXXX-XXXX-XXXX"

def check_price(product_url, price_selector):
    resp = requests.post(
        "https://api.iteratools.com/browser/act",
        headers={"Authorization": f"Bearer {ITERATOOLS_KEY}"},
        json={
            "actions": [
                {"type": "navigate", "url": product_url},
                {"type": "waitForSelector", "selector": price_selector},
                {"type": "extract", "selector": price_selector}
            ]
        }
    )
    data = resp.json()
    results = data.get("results", [])
    if results:
        return results[-1].get("text", "N/A")
    return None

price = check_price("https://amazon.com/dp/B09XYZ", ".a-price-whole")
print(f"Current price: ${price}")

Cost: $0.005 per check. Running this hourly costs ~$3.60/month.

Combining with Other IteraTools

The real power comes when you combine /browser/act with other tools:

Navigate + extract → Send extracted text to /tts for voice readout
Screenshot → Send the PNG to /image/ocr to extract text from rendered pages
Extract data → Pass to /chart/generate for instant visualization
Navigate to forms → Complete multi-step workflows fully automated

Why Not Just Use Playwright Directly?

You absolutely can. But if you're building AI agents or microservices that occasionally need to touch a browser:

No infra to manage — browser runs on our servers
No dependency hell — no Playwright/Chromium install in your Docker image
Works anywhere — call it from AWS Lambda, Cloudflare Workers, your LLM tool calls
Pay as you go — $0.005 per session, no monthly fee

Getting Started

Create a free API key at iteratools.com
Add credits (start with $1 = 200 browser sessions)
Start automating

Full docs: api.iteratools.com/docs
GitHub (MCP server): github.com/fredpsantos33/mcp-iteratools

IteraTools is a multi-tool API for AI agents: 24+ tools including image generation, web search, OCR, TTS, PDF, browser automation, and code execution. Pay-per-use with x402 micropayments.

Tags: ai, webdev, automation, api, llm

How I Built a Pay-Per-Use AI Toolkit: IteraTools Architecture Deep Dive

Fred Santos — Sun, 22 Mar 2026 20:14:36 +0000

How I Built a Pay-Per-Use AI Toolkit: IteraTools Architecture Deep Dive

A technical look at x402 micropayments, MCP protocol integration, and how to build an API your AI agents will love.

The Problem: AI Agents Need Tools, But APIs Are Messy

Building AI agents is exhilarating—until you hit the tooling wall.

You want your Claude or GPT-4 agent to generate an image. So you sign up for Replicate. Then it needs to scrape a webpage, so you add Firecrawl. Then it needs to convert text to speech, so you integrate ElevenLabs. Then OCR, weather, QR codes, charts...

Before long, your agent has eight API keys, eight different SDKs, eight different rate limit strategies, and eight monthly subscriptions—most of which you barely use.

This is the problem I set out to solve with IteraTools.

The Solution: One API, 34+ Tools, Pay Per Use

IteraTools is a hosted multi-tool API that gives your AI agents access to 34+ capabilities through a single, unified interface:

Media: Image generation (Flux), TTS, OCR, PDF generation
Web: Scraping, browser automation (Playwright), URL shortening
Data: Charts, QR codes, DNS lookup, WHOIS, IP geolocation
Finance: Crypto prices, currency conversion
Utilities: Weather, translation, code execution (E2B sandbox), holidays

Every tool speaks the same language: one base URL, one API key, consistent JSON responses.

But the really interesting part is how it handles payments.

The x402 Payment Protocol: Micropayments Without Subscriptions

Most APIs charge you monthly whether you use them or not. IteraTools uses x402, a payment protocol built on HTTP 402 ("Payment Required").

Here's how it works:

Your agent calls POST https://api.iteratools.com/image/generate
The server responds with HTTP 402 + a payment requirement header
Your agent pays the exact amount (e.g., $0.003 USDC) on-chain
The server verifies the payment and returns the result

In practice, with the Python SDK, this is transparent:

from anthropic import Anthropic
import httpx

client = Anthropic()
api_key = "your-iteratools-api-key"

# Call IteraTools directly - payment handled automatically
def generate_image(prompt: str) -> str:
    response = httpx.post(
        "https://api.iteratools.com/image/generate",
        headers={"X-API-Key": api_key},
        json={"prompt": prompt, "width": 512, "height": 512}
    )
    return response.json()["url"]

def scrape_url(url: str) -> str:
    response = httpx.post(
        "https://api.iteratools.com/scrape",
        headers={"X-API-Key": api_key},
        json={"url": url}
    )
    return response.json()["content"]

def text_to_speech(text: str) -> str:
    response = httpx.post(
        "https://api.iteratools.com/tts",
        headers={"X-API-Key": api_key},
        json={"text": text, "voice": "en-US-AriaNeural"}
    )
    return response.json()["audio_url"]

Per-call pricing means you pay $0.001–$0.005 per request. No monthly fees. No waste.

MCP Integration: Claude Desktop in 30 Seconds

The Model Context Protocol (MCP) is Anthropic's standard for giving AI models access to external tools. IteraTools ships a native MCP server.

Install:

npm install -g mcp-iteratools

Configure Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "iteratools": {
      "command": "npx",
      "args": ["mcp-iteratools"],
      "env": {
        "ITERATOOLS_API_KEY": "your-api-key-here"
      }
    }
  }
}

Restart Claude Desktop, and you'll see IteraTools listed under available tools. Claude can now generate images, scrape websites, run code, check DNS records—all within a single conversation, with zero additional setup.

The MCP server exposes all 34+ tools as individual MCP tools, with proper schemas and descriptions so Claude knows exactly when and how to use each one.

Code Example: A 3-Tool Python Agent

Here's a real-world example: an agent that researches a company, generates a summary chart, and creates a voice briefing.

from anthropic import Anthropic
import httpx
import json

client = Anthropic()
API_KEY = "your-iteratools-api-key"
BASE_URL = "https://api.iteratools.com"

def call_tool(endpoint: str, payload: dict) -> dict:
    r = httpx.post(
        f"{BASE_URL}{endpoint}",
        headers={"X-API-Key": API_KEY},
        json=payload,
        timeout=30
    )
    r.raise_for_status()
    return r.json()

# Tool definitions for Claude
tools = [
    {
        "name": "scrape_website",
        "description": "Scrape and extract text content from a URL",
        "input_schema": {
            "type": "object",
            "properties": {
                "url": {"type": "string", "description": "URL to scrape"}
            },
            "required": ["url"]
        }
    },
    {
        "name": "generate_chart",
        "description": "Generate a bar or pie chart from data",
        "input_schema": {
            "type": "object",
            "properties": {
                "config": {
                    "type": "object",
                    "description": "Chart.js config object with type, data, and options"
                }
            },
            "required": ["config"]
        }
    },
    {
        "name": "text_to_speech",
        "description": "Convert text to an audio file",
        "input_schema": {
            "type": "object",
            "properties": {
                "text": {"type": "string"},
                "voice": {"type": "string", "default": "en-US-AriaNeural"}
            },
            "required": ["text"]
        }
    }
]

def run_agent(company_url: str):
    messages = [
        {
            "role": "user",
            "content": f"Research {company_url}, then create a simple chart showing their key metrics (make them up if needed), and finally generate a short voice briefing summarizing what you found."
        }
    ]

    while True:
        response = client.messages.create(
            model="claude-opus-4-5",
            max_tokens=1024,
            tools=tools,
            messages=messages
        )

        if response.stop_reason == "end_turn":
            print("Agent done:", response.content[-1].text)
            break

        # Handle tool calls
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                print(f"  → Calling {block.name}...")

                if block.name == "scrape_website":
                    result = call_tool("/scrape", {"url": block.input["url"]})

                elif block.name == "generate_chart":
                    result = call_tool("/chart/generate", {
                        "config": block.input["config"],
                        "format": "png"
                    })

                elif block.name == "text_to_speech":
                    result = call_tool("/tts", {
                        "text": block.input["text"],
                        "voice": block.input.get("voice", "en-US-AriaNeural")
                    })

                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result)
                })

        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})

# Run it
run_agent("https://stripe.com")

Total cost for this workflow: about $0.007 USDC (scrape + chart + TTS). Compare that to paying three different API subscriptions.

Architecture: How It All Fits Together

Claude / GPT Agent
      ↓ (MCP or REST)
IteraTools API (api.iteratools.com)
      ↓
  Route handler
      ↓
  x402 auth middleware  ←→  Payment verification
      ↓
  Tool executor
  ├── Flux (image gen)
  ├── Playwright (browser)
  ├── E2B (code execution)
  ├── Node.js builtins (DNS, crypto)
  └── Third-party APIs (weather, etc.)

The server runs on Node.js with Express. Each tool is a self-contained module. The x402 middleware sits in front of all endpoints, checking for a valid API key or on-chain payment before routing the request to the executor.

This architecture makes it trivial to add new tools: write a handler, add it to the router, update the MCP schema. Done.

What's Next

A few things I'm working on:

Streaming support — Long-running tasks (browser sessions, code execution) should stream results back to the agent in real time
Tool chaining — Let you define multi-step pipelines server-side and execute them atomically with one API call
npm publish — The MCP package is ready, just needs publishing for npx support without global install
More tools — /sentiment, /summarize, /email/send are next on the roadmap

Try It

API: api.iteratools.com
Docs: iteratools.com
MCP package: github.com/fredpsantos33/mcp-iteratools

If you're building AI agents and tired of juggling APIs, give it a shot. The first few calls are free — just generate an API key and go.

Questions or feedback? Open an issue on GitHub or reach out in the comments below.

Best Web Scraping APIs That Require Zero Installation (IteraTools vs Apify vs ScrapingBee)

Fred Santos — Sun, 22 Mar 2026 15:50:46 +0000

Best Web Scraping APIs That Require Zero Installation (IteraTools vs Apify vs ScrapingBee)

Setting up a web scraper locally means Puppeteer, Playwright, managing Chrome binaries, handling proxies, and fighting anti-bot systems. For many use cases — especially in production — a scraping API is far more practical.

The promise: send a URL, get back HTML or structured data. No browser to manage, no proxy rotation to configure, no CAPTCHA headaches. This guide compares the leading options.

What to Consider When Choosing a Scraping API

JavaScript rendering: Can it handle SPAs and dynamically loaded content?
Anti-bot bypass: Does it handle Cloudflare, CAPTCHA, and fingerprinting?
Response format: Raw HTML, markdown, or structured JSON?
Speed: Time to first byte matters for real-time use cases.
Price: Per-page or per-credit; watch for hidden costs (JS rendering often costs extra).
Rate limits: Can it handle burst traffic for bulk scraping jobs?

Comparison Table

Tool	Price	JS Rendering	Anti-Bot	Output Format	Limitations
IteraTools	~$0.002/request (credits)	Yes (headless Chrome)	Basic	HTML, markdown, text	Less advanced anti-bot
Apify	$49+/mo or per compute	Yes (full browser)	Excellent	Flexible (actors)	Complex actor model
ScrapingBee	$49+/mo (250K credits)	Yes	Very Good	HTML, JSON	Expensive for high volume
Browserless	$100+/mo	Yes	Good	Raw browser API	Requires code
Jina AI Reader	Free tier / credits	Basic	None	Markdown	Limited control

IteraTools Scraping — How to Use It

Simple page fetch with markdown output:

curl -X POST https://api.iteratools.com/v1/scrape \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://news.ycombinator.com",
    "render_js": false,
    "output": "markdown"
  }'

For JavaScript-rendered pages:

curl -X POST https://api.iteratools.com/v1/scrape \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://app.example.com/dashboard",
    "render_js": true,
    "wait_for": ".data-loaded",
    "output": "html"
  }'

For crawling multiple pages:

curl -X POST https://api.iteratools.com/v1/crawl \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://docs.example.com",
    "max_pages": 50,
    "output": "markdown"
  }'

Complete Python Example

import requests
import json

API_KEY = "your_api_key_here"
BASE_URL = "https://api.iteratools.com/v1"

def scrape_page(url: str, render_js: bool = False) -> dict:
    """Scrape a single page."""
    response = requests.post(
        f"{BASE_URL}/scrape",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "url": url,
            "render_js": render_js,
            "output": "markdown"
        }
    )
    response.raise_for_status()
    return response.json()

def crawl_site(start_url: str, max_pages: int = 20) -> list[dict]:
    """Crawl a site and return all pages."""
    response = requests.post(
        f"{BASE_URL}/crawl",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "url": start_url,
            "max_pages": max_pages,
            "output": "markdown"
        }
    )
    response.raise_for_status()
    return response.json()["pages"]

def scrape_for_llm(url: str) -> str:
    """Scrape a page and return clean text for LLM processing."""
    result = scrape_page(url, render_js=True)
    return result.get("markdown", result.get("text", ""))

if __name__ == "__main__":
    # Example 1: Scrape a news site
    result = scrape_page("https://techcrunch.com", render_js=False)
    print(f"Scraped {len(result['markdown'])} chars")
    print(result["markdown"][:500])

    # Example 2: Build a knowledge base from docs
    pages = crawl_site("https://docs.iteratools.com", max_pages=30)
    knowledge_base = []
    for page in pages:
        knowledge_base.append({
            "url": page["url"],
            "title": page["title"],
            "content": page["markdown"]
        })

    with open("knowledge_base.json", "w") as f:
        json.dump(knowledge_base, f, indent=2)

    print(f"Knowledge base: {len(knowledge_base)} pages saved")

    # Example 3: Scrape for RAG pipeline
    urls = [
        "https://example.com/page1",
        "https://example.com/page2",
        "https://example.com/page3"
    ]

    documents = []
    for url in urls:
        text = scrape_for_llm(url)
        documents.append({"url": url, "text": text})
        print(f"✓ {url}: {len(text)} chars")

Use Cases by Tool

IteraTools: Best for developers who need scraping + other capabilities (screenshots, PDF extraction, search) in one API. Perfect for building RAG pipelines and AI agents.
Apify: Best for complex scraping workflows with the actor marketplace — pre-built scrapers for Amazon, LinkedIn, etc.
ScrapingBee: Best for enterprise-grade anti-bot bypass with detailed documentation and dedicated support.

Conclusion

If you need web scraping as one of many tools in your stack (not your core business), IteraTools is the most practical choice: single API key, credit-based pricing, and you also get screenshot, crawl, PDF, and 60+ other endpoints. No CLI tools, no proxies to manage.

For high-volume scraping with advanced anti-bot requirements, ScrapingBee or Apify are worth the higher price.

→ Start scraping with IteraTools — no monthly commitment.

Best Text-to-Speech APIs for Portuguese in 2025 (IteraTools vs ElevenLabs vs OpenAI TTS)

Fred Santos — Sun, 22 Mar 2026 15:50:04 +0000

Best Text-to-Speech APIs for Portuguese in 2025 (IteraTools vs ElevenLabs vs OpenAI TTS)

Building a voice feature for a Brazilian or Portuguese app? The quality of text-to-speech in Portuguese varies dramatically between providers. Some APIs sound robotic, others require complex SDKs, and pricing can spiral quickly at production volumes.

This guide compares the top TTS API options with a focus on Portuguese language quality, developer experience, and cost-effectiveness.

What to Consider When Choosing a TTS API

Portuguese quality: Does it handle regional accents (BR vs PT)? How natural are the prosody and intonation?
Latency: Streaming vs batch — do you need real-time audio or async generation?
Voice selection: Fixed voices or cloning capabilities?
Format support: MP3, WAV, OGG — and what sample rates?
Price at scale: Cost per character or per request matters at production volumes.
Setup complexity: API key only vs SDK installation required.

Comparison Table

Tool	Price	Portuguese Quality	Setup	Limitations
IteraTools	~$0.001/request (credits)	Good (Neural voices, pt-BR)	API key, plain HTTP	Voice cloning not available
ElevenLabs	$0.30/1K chars (Starter)	Excellent (cloning, multi-accent)	API key	Expensive at scale
OpenAI TTS	$0.015/1K chars	Good (pt-BR supported)	API key	Limited voice customization
Azure TTS	$4/1M chars	Excellent (200+ pt voices)	Complex SDK + account	Enterprise setup overhead
Google TTS	$4/1M chars	Very Good	SDK required	Requires GCP account

IteraTools TTS — How to Use It

curl -X POST https://api.iteratools.com/v1/tts \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Olá! Bem-vindo ao nosso sistema de atendimento automático.",
    "language": "pt-BR",
    "voice": "antonio",
    "format": "mp3"
  }' \
  --output audio.mp3

Response is the audio file directly (binary), or you can get a URL:

curl -X POST https://api.iteratools.com/v1/tts \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Seu pedido foi confirmado com sucesso.",
    "language": "pt-BR",
    "voice": "antonio",
    "format": "mp3",
    "return_url": true
  }'

{
  "url": "https://cdn.iteratools.com/audio/tts/xyz789.mp3",
  "duration_seconds": 2.4,
  "credits_used": 1
}

Complete Python Example

import requests
from pathlib import Path

API_KEY = "your_api_key_here"

def text_to_speech(
    text: str,
    output_file: str = "output.mp3",
    language: str = "pt-BR",
    voice: str = "antonio"
) -> str:
    """Convert text to speech and save audio file."""
    response = requests.post(
        "https://api.iteratools.com/v1/tts",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "text": text,
            "language": language,
            "voice": voice,
            "format": "mp3",
            "return_url": True
        }
    )
    response.raise_for_status()
    data = response.json()

    # Download audio
    audio = requests.get(data["url"])
    Path(output_file).write_bytes(audio.content)

    print(f"Audio saved: {output_file}")
    print(f"Duration: {data['duration_seconds']:.1f}s")
    print(f"Credits used: {data['credits_used']}")
    return data["url"]

def batch_tts(texts: list[str], output_dir: str = ".") -> list[str]:
    """Convert multiple texts to speech."""
    urls = []
    for i, text in enumerate(texts):
        url = text_to_speech(
            text,
            output_file=f"{output_dir}/audio_{i+1:03d}.mp3"
        )
        urls.append(url)
    return urls

if __name__ == "__main__":
    # Single conversion
    text_to_speech(
        "Seu pagamento foi aprovado! Obrigado por comprar conosco.",
        "payment_confirmation.mp3"
    )

    # Batch conversion for IVR system
    ivr_messages = [
        "Bem-vindo. Pressione um para suporte técnico.",
        "Pressione dois para faturamento.",
        "Pressione três para falar com um atendente."
    ]
    batch_tts(ivr_messages, output_dir="ivr_audio")

Portuguese-Specific Considerations

When choosing a TTS API for Portuguese, watch out for:

BR vs PT accent: pt-BR (Brazilian) and pt-PT (European Portuguese) sound very different. Make sure the API supports your target variant.
Abbreviations: APIs vary in how they handle "Dr.", "R$", "km/h" — test these before committing.
SSML support: For fine-grained control over pauses, emphasis, and pronunciation, SSML support is important for professional IVR systems.

Conclusion

For developers building Portuguese-language voice features, the choice depends on your use case:

IteraTools: Best for budget-conscious projects that need Portuguese TTS as part of a broader API toolkit (also handles scraping, WhatsApp, PDF, etc.). Credit-based, no monthly fees.
ElevenLabs: Best for high-quality voice cloning or when voice naturalness is critical (e.g., content creation).
OpenAI TTS: Good quality, easy integration if you're already in the OpenAI ecosystem.

Get started at api.iteratools.com — no monthly commitment, pay-as-you-go credits.

Best Image Generation APIs for Developers in 2025 (IteraTools vs Replicate vs Stability AI)

Fred Santos — Sun, 22 Mar 2026 15:49:59 +0000

Best Image Generation APIs for Developers in 2025 (IteraTools vs Replicate vs Stability AI)

You want to add AI image generation to your app. You don't want to manage GPU servers, deal with complex SDKs, or pay for idle infrastructure. You just want a simple HTTP call that returns an image.

The good news: several API providers have solved this. The bad news: they differ wildly in pricing, setup complexity, output quality, and rate limits. This guide compares the top options so you can pick the right one for your use case.

What to Consider When Choosing an Image Generation API

Before diving into comparisons, here are the key criteria that actually matter for developers:

Price per image: Some providers charge per second of compute, others per image. Understand the billing model.
Setup friction: Do you need to install a client SDK, or can you use plain HTTP?
Model variety: Can you switch between SDXL, FLUX, or custom fine-tunes?
Speed (latency): Cold starts can kill UX. Look for warm inference or async queues.
Rate limits: Free tiers are often unusable for production; check paid limits.
Output control: Resolution, aspect ratio, negative prompts, LoRAs, etc.

Comparison Table

Tool	Price	Setup	Model Options	Limitations
IteraTools	~$0.003/image (credits)	Single API key, plain HTTP	FLUX, SDXL, others	Newer player
Replicate	$0.003–$0.05/prediction	API key + model path	1000s of models	Pay-per-prediction varies widely
Stability AI	$0.01–$0.06/image	API key	Stable Diffusion family	Limited to Stability models
OpenAI DALL-E 3	$0.04–$0.12/image	API key	DALL-E 3 only	Expensive, no SD models
Fal.ai	$0.003–$0.020/image	API key + SDK	FLUX, SD	SDK preferred, docs complex

IteraTools Image Generation — How to Use It

IteraTools provides a single endpoint for image generation with no SDK required:

curl -X POST https://api.iteratools.com/v1/image/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a futuristic city at sunset, photorealistic",
    "model": "flux",
    "width": 1024,
    "height": 1024
  }'

Response:

{
  "url": "https://cdn.iteratools.com/images/generated/abc123.png",
  "width": 1024,
  "height": 1024,
  "credits_used": 3
}

You can then chain this with IteraTools' own rembg endpoint to remove backgrounds, or resize to create thumbnails — all in the same API.

Complete Python Example

import requests
import base64
from pathlib import Path

API_KEY = "your_api_key_here"
BASE_URL = "https://api.iteratools.com/v1"

def generate_image(prompt: str, output_path: str = "output.png") -> str:
    """Generate an image and save it locally."""
    response = requests.post(
        f"{BASE_URL}/image/generate",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "prompt": prompt,
            "model": "flux",
            "width": 1024,
            "height": 1024
        }
    )
    response.raise_for_status()
    data = response.json()

    # Download the generated image
    img_url = data["url"]
    img_response = requests.get(img_url)

    Path(output_path).write_bytes(img_response.content)
    print(f"Image saved to {output_path}")
    print(f"Credits used: {data['credits_used']}")

    return img_url

def generate_and_remove_background(prompt: str) -> str:
    """Generate image then remove its background."""
    # Step 1: Generate
    img_url = generate_image(prompt, "original.png")

    # Step 2: Remove background
    rembg_response = requests.post(
        f"{BASE_URL}/image/rembg",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"url": img_url}
    )
    rembg_response.raise_for_status()
    result = rembg_response.json()

    # Download transparent PNG
    img_data = requests.get(result["url"])
    Path("no_background.png").write_bytes(img_data.content)
    print("Background removed: no_background.png")

    return result["url"]

if __name__ == "__main__":
    # Generate a product image with transparent background
    url = generate_and_remove_background(
        "a sleek black wireless headphone on white background, product photography"
    )
    print(f"Final image URL: {url}")

When to Choose Each Option

IteraTools: Best for developers who want multiple AI capabilities in one API (image + scraping + PDF + WhatsApp, etc.) with predictable credit-based pricing. No SDK to install.
Replicate: Best if you need access to thousands of community models or want to deploy your own fine-tuned models.
Stability AI: Best if you're building specifically with Stable Diffusion and want official support.
DALL-E 3: Best for highest prompt adherence and integration with OpenAI ecosystem; expensive for high volumes.

Conclusion

For most developers building apps with image generation, IteraTools stands out for its simplicity — one API key, plain HTTP, and you also get 60+ other endpoints (web scraping, PDF parsing, background removal) bundled in. At ~$0.003/image, it's cost-competitive with the leading alternatives.

Start at api.iteratools.com — credits are pre-paid with no monthly fees or idle charges.

WhatsApp Market Research via API: Survey 50 Contacts with One API Call

Fred Santos — Fri, 20 Mar 2026 08:06:09 +0000

The Problem: Market Research is Still Painfully Manual

Picture this: you need to survey 50 local suppliers about delivery times, prices, and capacity. The traditional approach?

Export a list of phone numbers
Open WhatsApp one by one
Send the same message 50 times
Wait for replies, copy answers into a spreadsheet
Follow up with the next question manually
Repeat for every question

This is a data collection nightmare — and it hasn't changed much in years. Even with WhatsApp Business, automating a multi-step questionnaire requires building your own bot, managing conversation state, handling webhooks, and formatting the final report.

What if you could do all of that with a single API call?

The Solution: POST /whatsapp/research

IteraTools now has a dedicated market research endpoint. You provide a list of phone numbers and a list of questions — the API handles everything else:

Sends each contact the initial greeting
Asks the first question
Captures their reply
Sends the next question automatically
Generates a structured report when everyone's done

No webhook setup. No conversation state management. No spreadsheet assembly.

The 4 Endpoints

1. `POST /whatsapp/research/start` — Launch the research

curl -X POST https://api.iteratools.com/whatsapp/research/start \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "numbers": [
      "+5548991234567",
      "+5511987654321",
      "+5521998765432"
    ],
    "questions": [
      "Qual seu prazo médio de entrega?",
      "Qual o preço médio por unidade?",
      "Vocês atendem pessoa jurídica?",
      "Quantas unidades vocês conseguem entregar por semana?"
    ]
  }'

Response:

{
  "ok": true,
  "research_id": "res_abc123def456",
  "total_contacts": 3,
  "messages_sent": 3,
  "status": "started"
}

Each contact receives: "Olá! Gostaríamos de fazer algumas perguntas rápidas. Pode nos ajudar?" followed by question #1.

Price: $0.070 per contact (covers the WhatsApp conversation initiation cost).

2. `GET /whatsapp/research/:id` — Track progress

curl https://api.iteratools.com/whatsapp/research/res_abc123def456 \
  -H "Authorization: Bearer YOUR_API_KEY"

Response:

{
  "ok": true,
  "research_id": "res_abc123def456",
  "status": "in_progress",
  "total": 3,
  "responded": 1,
  "pending": 2,
  "contacts": [
    { "number": "+5548991234567", "status": "done", "current_question": 4, "answers_count": 4 },
    { "number": "+5511987654321", "status": "in_progress", "current_question": 2, "answers_count": 2 },
    { "number": "+5521998765432", "status": "contacted", "current_question": 0, "answers_count": 0 }
  ]
}

Price: $0.001

3. `POST /whatsapp/research/:id/answer` — Internal webhook (auto-called)

This endpoint powers the "auto-advance" behavior. When a contact replies to a WhatsApp message, the webhook receives the message and calls this endpoint internally:

curl -X POST https://api.iteratools.com/whatsapp/research/res_abc123/answer \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "number": "+5548991234567",
    "answer": "3 dias úteis"
  }'

Response:

{
  "ok": true,
  "status": "in_progress",
  "next_question": "Qual o preço médio por unidade?",
  "answers_recorded": 1
}

When all questions are answered:

{
  "ok": true,
  "status": "done",
  "answers_recorded": 4
}

The contact also receives: "Obrigado pelas respostas! Isso nos ajudará muito. 🙏"

Price: $0.001

4. `GET /whatsapp/research/:id/report` — Get the structured report

curl https://api.iteratools.com/whatsapp/research/res_abc123def456/report \
  -H "Authorization: Bearer YOUR_API_KEY"

Response:

{
  "ok": true,
  "research_id": "res_abc123def456",
  "status": "completed",
  "completed_at": "2026-03-19T17:30:00Z",
  "summary": {
    "total": 3,
    "responded": 3,
    "pending": 0,
    "completion_rate": "100%"
  },
  "responses": [
    {
      "number": "+5548991234567",
      "answers": [
        { "question": "Qual seu prazo médio de entrega?", "answer": "3 dias úteis" },
        { "question": "Qual o preço médio por unidade?", "answer": "R$ 25,00" },
        { "question": "Vocês atendem pessoa jurídica?", "answer": "Sim, com nota fiscal" },
        { "question": "Quantas unidades vocês conseguem entregar por semana?", "answer": "Até 500 unidades" }
      ]
    }
  ]
}

Price: $0.001

Use Cases

Price discovery

Survey 20 local suppliers for the same product. Get back a structured table of prices, MOQs, and lead times — without writing a line of scraping code.

Supplier qualification

Ask questions about certifications, capacity, location, and payment terms. Filter and rank based on responses.

Customer satisfaction (NPS)

Send a 3-question survey to recent customers via WhatsApp (highest open rate of any channel).

Availability checks

"Can you deliver X units by date Y?" — Run this against 10 vendors in parallel. Get answers in your app.

Competitive intelligence

Survey distributors or retailers about competitor pricing and stock levels.

How it works under the hood

The API stores each research session in SQLite with two tables:

wa_research — session metadata (questions, status, api_key)
wa_research_contacts — per-contact state (current_question, answers JSON array)

When a WhatsApp reply comes in via the Meta Cloud API webhook, the system looks up any active research session for that phone number and automatically calls the /answer endpoint internally. This advances the conversation without any client-side logic.

Pricing Summary

Endpoint	Price
POST /whatsapp/research/start	$0.070 / contact
GET /whatsapp/research/:id	$0.001
POST /whatsapp/research/:id/answer	$0.001
GET /whatsapp/research/:id/report	$0.001

For 10 contacts + 1 status check + 1 report: $0.702 total.

Compare that to a market research firm charging $5–$20 per completed survey.

AI Agent Integration (MCP)

The endpoint is also available as an MCP tool (whatsapp_research_start, whatsapp_research_status, whatsapp_research_report) via the iteratools-mcp npm package:

npx -y iteratools-mcp

This lets AI agents like Claude, GPT-4o, or Cursor use the research tools directly — no API client needed.

Get Started

API: api.iteratools.com
Docs: iteratools.com/docs
Tool page: iteratools.com/tools/whatsapp-research

The API uses x402 micropayments on Base (USDC) — you pay per call, no subscription required. Or use a Bearer API key for higher volume.

Questions? Open an issue or reach out via the docs page.