API Anything Explained: Turn Any Website into Fast Agent Tooling

When autonomous coding agents like Claude Code, Cursor, or Codex need real-world data from websites without public APIs, developers instinctively hand them a headless browser. You tell the agent to look up a flight on Google Flights, check an author’s rating on Goodreads, or fetch a candidate’s profile on LinkedIn. Behind the scenes, the agent boots a full Chromium binary. It burns 600MB of host memory, waits fifteen seconds for client-side JavaScript hydration, and dumps eighty thousand tokens of messy HTML into the model context window.

The transaction costs thirty cents, drags like lead, and shatters the moment a designer tweaks a CSS class.

For years, engineers accepted this browser overhead as an inevitable tax of agentic autonomy. If a target platform hid behind closed web interfaces without documentation or public REST keys, launching a virtual display seemed like the only viable bridge. But browser automation is an extraordinarily wasteful vehicle for reading tabular data. Websites do not generate their data in the browser: their frontend user interfaces fetch raw JSON payloads from internal backend endpoints via standard HTTP requests.

On September 27, 2026, robotics engineer Charles Zheng open-sourced API Anything (goodnight000/api-anything), an MIT-licensed engine engineered to dismantle this browser tax. Instead of forcing agents to drive Chrome on every query, API Anything launches the browser exactly once, captures the frontend’s native network traffic, extracts parameterized slots across decoded protocol layers without using an LLM, and stores a pristine request template.

Subsequent queries bypass the browser completely: your agent issues direct, sub-second Node HTTP calls, consuming a fraction of the tokens while automatically repairing itself whenever the underlying website changes.

TL;DR

Quick Answer Box (Google Search Featured Snippet): What is API Anything? An open-source TypeScript runtime and MCP (Model Context Protocol: universal standard for AI tool execution) server that translates interactive websites into fast, self-healing HTTP endpoints for AI coding agents. It drives a browser once to capture network traffic, maps parameters across decoded URL and JSON layers without language models, replays calls via plain HTTP in 120 milliseconds, and reactively re-triggers browser capture to heal broken templates when sites drift.

Primary Repository: goodnight000/api-anything · License: MIT · Stars: ~1,600+ · Language: Node 22.13+ TypeScript

• The Zero-LLM Slot Matcher: API Anything avoids hallucination-prone prompt engineering for endpoint generation. It walks decoded protocol layers (URL paths, query strings, form fields, and nested JSON strings) to bind example arguments directly into verbatim request slots.
• Sub-Second Execution Speed: Replayed operations execute over native Node fetch in 100 to 300 milliseconds, slashing agent wait times by 90% compared to headless Playwright pipelines.
• Reactive Self-Healing: The matcher tracks stable endpoint identities (HTTP method, host, path wildcard, and GraphQL operationName), strictly ignoring volatile query IDs. When a site shifts, it triggers a single browser re-capture and auto-updates the spec.
• The 4-Tier Transport Ladder: Operations escalate gracefully from direct HTTP (Tier 1) to in-page JavaScript execution (Tier 2), browser intercept (Tier 3), and manual human CAPTCHA resolution (Tier 4).

Beginner Map (Mental Model)

Think of API Anything as a master hotel concierge shadowing a guest. Instead of making you walk upstairs and push open the kitchen doors every time you want breakfast, the concierge watches you order room service once, memorizes the internal telephone extension and order codes, and dials the kitchen directly on your behalf.

Part 1: Foundations (The Browser Trap & Slot Decoding)

Modern coding agents spend vast compute budgets navigating websites through high-level automation drivers like Playwright or Puppeteer. Every interaction requires launching a Chromium helper, navigating complex DOM (Document Object Model: the structured HTML tree of a web page) trees, waiting for network idle events, and parsing accessibility snapshots.

This introduces three crippling operational bottlenecks:

1. Context Window Saturation: Converting an interactive flight search page into an LLM-readable accessibility tree dumps between 30,000 and 80,000 tokens of boilerplate into the agent’s context. A single research task can exhaust context budgets within four iterations.
2. Execution Latency: Browser rendering, font downloading, and client bundle execution introduce 10 to 30 seconds of round-trip latency per query.
3. Visual Fragility: Frontends evolve constantly. A CSS update that changes an input selector from button.search-btn to a hashed Tailwind class instantly derails an agent.

Prior commercial tools like Unbrowse attempted to solve this by creating centralized reverse-engineering services. However, Unbrowse bundled proprietary cloud dependencies, charged micropayments, and relied on brittle matchers that recorded dynamic GraphQL document hashes (queryId). Whenever an upstream engineering team deployed a frontend bundle with new query hashes, Unbrowse broke and failed to recover.

API Anything takes a strictly decentralized, local-first approach. Its core insight is structural slot matching. When you teach API Anything a new site, it does not send the raw network stream to an LLM to guess what changed. Instead, its internal engine (src/learn.ts) walks through every decoded layer of the captured exchange:

Decoded Hierarchy Walk:
HTTP Request
├── URL Path Segments      -> path:0, path:1
├── Query Parameters       -> query:variables
│   └── Decoded JSON       -> json:/screen_name (Slot identified)
├── Form URL-Encoded Body  -> form:f.req
│   └── Escaped JSON Str   -> json:/1/0/0 (Slot identified)
└── Custom Auth Headers    -> header:x-csrf-token

By traversing nested JSON strings, base64-encoded envelopes, and URL parameters, the engine identifies exactly where example arguments reside. It replaces those locations with parameterized slots while preserving every untouched byte, header order, and character encoding verbatim.

Part 2: Investigation (How API Anything Operates)

Setting up API Anything inside an AI agent workspace requires Node 22.13 or newer. The runtime compiles into a single CLI binary and connects directly to Claude Code, Cursor, or Antigravity via MCP.

Step 1: Connecting the MCP Server

You can install API Anything globally and expose its pre-bundled site operations (including Google Flights, Goodreads, LinkedIn, and Amazon) to your agent:

# Install API Anything from GitHub
npm install -g git+https://github.com/goodnight000/api-anything.git

# Expose MCP server to Claude Code
claude mcp add api-anything -- api-anything mcp

Once connected, the agent receives native tools formatted as api_anything__<site>__<operation> with typed arguments validated by Zod (TypeScript runtime schema validation library).

Step 2: Teaching a New Site Operation

Teaching the engine a new website requires defining a trigger URL and passing example arguments. Consider teaching the agent how to fetch user profiles on a social network:

# Learn an operation by running a single browser trigger
api-anything learn \
  --site "social" \
  --op "getUser" \
  --trigger "https://example.com/users/{username}" \
  --example username="octocat"

The learner launches a headless browser, navigates to the trigger URL, and intercepts network exchanges. It strips out noise (analytics beacons, static fonts, CSS assets) and filters for candidate responses that return structured JSON containing the example data.

The resulting spec is saved locally into sites/social.json. Here is what the internal slot contract looks like:

{
  "name": "getUser",
  "method": "GET",
  "url": "https://api.example.com/graphql",
  "match": {
    "host": "api.example.com",
    "path": "/graphql",
    "operationName": "UserProfileQuery"
  },
  "slots": [
    {
      "param": "username",
      "at": ["query:variables", "json:/username"]
    },
    {
      "ref": "cookie:session_token",
      "at": ["header:authorization"],
      "template": "Bearer {value}"
    }
  ]
}

Notice that the match block completely omits ephemeral build hashes. It identifies the request solely by host, endpoint path, and GraphQL operation name. If the server shifts its internal queryId from a1b2c3 to d4e5f6, API Anything still recognizes the intent during reactive re-capture.

Step 3: Sub-Second Replay via Plain HTTP

When the agent executes social.getUser(username="torvalds"), API Anything does not open Chrome. Its execution engine (src/execute.ts) executes a Tier 1 plain HTTP request:

# Agent executes operation directly from terminal or MCP
api-anything call social getUser username="torvalds"

The runtime decodes only the layers touched by the username slot, substitutes "torvalds", re-encodes the query parameter, attaches necessary cookies from the local session jar, and dispatches a lightweight Node fetch. The call completes in 120 milliseconds, returning clean JSON directly into the agent’s context.

Part 3: Diagnosis (The Rough Edges & Traps)

While API Anything delivers dramatic speedups over traditional browser automation, deploying reverse-engineered network calls into production surfaces subtle edge cases and security boundaries.

Developer discussions on X quickly highlighted the contrast between heavy browser drivers and direct API execution:

However, engineering teams testing the runtime across aggressive edge networks soon uncovered critical transport traps:

Trap 1: The HTTP 419 False-Auth Fingerprint (Issue #12)

Certain edge firewalls and Laravel-backed platforms inspect incoming TLS handshakes. When API Anything dispatches a Tier 1 Node fetch with manual redirect handling, edge networks flag the non-browser TLS fingerprint and return HTTP 419: CSRF check failed.

In early builds, API Anything’s response classifier mapped any 419 status directly to classification auth (credential failure). Because auth errors assumed expired login tokens, the execution ladder refused to escalate transport tiers. The entire call stalled, even though the page loaded cleanly in Chrome.

The maintainers resolved this in recent commits: when an unauthenticated read receives an HTTP 419, the ladder escalates to Tier 2 (executing fetch from within a real Chrome tab), bypassing TLS fingerprinting without manual intervention.

Trap 2: Secret Leakage & URL Cookie Collisions (Issue #27)

To prevent users from accidentally committing session cookies or API keys into version control, API Anything includes an automated credential scanner (src/secrets.ts). Before saving an operation spec, it scans captured request payloads against active cookies.

On sites running modern web analytics, scripts frequently store the current page URL inside a tracking cookie (e.g., __ps_lu=https%3A%2F%2Fexample.com%2F). Because the target request URL inherently matches the site’s origin, the scanner flagged a false-positive collision:

Error: refusing to learn a request that would keep a credential in the spec:
$.request.url holds the live cookie __ps_lu

The fix requires ignoring cookies whose decoded values represent plain URLs without query strings. If you encounter this on custom sites, pass --public <cookie_name> to explicitly allow non-sensitive tracking tokens.

Trap 3: The Idempotency Hazard of Write Operations

API Anything bundles read operations almost exclusively. While the engine can technically learn POST endpoints that submit forms or post messages, executing writes through reverse-engineered APIs carries severe risks.

If a write operation fails due to network packet loss, automatic self-healing cannot safely replay the request. Re-triggering a payment or message submission in a browser could double-charge a card or duplicate user actions. API Anything strictly enforces that write operations must declare a verified readback check before marking a task as applied.

Part 4: Resolution (Decision Matrix)

Final Take

Do not force your AI agents to steer a two-ton browser locomotive when all they need is a two-kilobyte JSON payload.

Student First Assignment

Install the API Anything CLI locally on Node 22+ and connect it to your terminal:

# Clone and verify the test harness
git clone https://github.com/goodnight000/api-anything.git
cd api-anything
npm install
npm test

Inspect sites/goodreads.json to examine how its authors mapped GraphQL queries into slots, then test a live query:

npx tsx src/cli.ts call goodreads getBookByTitle title="Piranesi"

Verify that the response returns pristine JSON in under 300 milliseconds without booting a single Chrome window.

Frequently Asked Questions (FAQ)

Does API Anything bypass Cloudflare or CAPTCHA challenges automatically?

No. API Anything deliberately avoids participating in the anti-bot bypass arms race. If a website presents an interactive challenge (such as Cloudflare Turnstile or Arkose Labs), the runtime marks the operation as blocked. You must solve the challenge once in a headed browser window, allowing API Anything to harvest the authenticated session cookies for subsequent HTTP calls.

How does API Anything differ from traditional web scrapers like BeautifulSoup or Cheerio?

Traditional scrapers parse static HTML markup using CSS selectors, which break whenever a website updates its visual layout. API Anything intercepts the underlying JSON network exchanges that power the user interface. It talks directly to the site’s backend data tier, ignoring CSS classes, visual layout shifts, and DOM hierarchies entirely.

Can API Anything handle operations that require user login?

Yes. You can run api-anything login <site>, which launches a headed Chrome browser where you complete authentication manually. The runtime captures the resulting session cookies and stores them in a local, encrypted session jar. Future requests inject these authentication headers automatically.