TinyFish: Web Infrastructure for AI Agents
Christian Pickett
Co-founder
The web is where many useful workflows still live. Some sites have APIs. Many do not. Others have the right data behind login, JavaScript, anti-bot systems, forms, pagination, or pages that were built for humans instead of agents.
Today we're excited to announce our partnership with TinyFish, a web infrastructure platform for AI agents, now available on Orthogonal. TinyFish gives agents a way to search the web, fetch clean content, run goal-based browser automation, create source-backed research reports, and control remote browser sessions from code.
What is TinyFish?
TinyFish provides five public API surfaces for web-native agents: Agent, Research, Search, Fetch, and Browser. Search returns structured ranked web results. Fetch turns URLs into clean extracted content. Agent executes natural-language goals on real websites. Research searches, evaluates sources, and synthesizes cited reports. Browser creates remote browser sessions for direct Playwright or CDP control.
The useful part is the range. A workflow can start with Search to find relevant pages, use Fetch to turn those pages into clean text, call Agent when the task requires clicks or form steps, use Research when the answer needs evidence across sources, and drop to Browser when a developer wants direct low-level control.
That makes TinyFish a strong fit for agents that need to use the live web instead of relying only on static APIs. A research agent can discover sources and produce a cited brief. A GTM agent can extract public account context from pages that change every day. An operations agent can complete browser workflows on websites that were never designed for automation. A data agent can combine search, extraction, and interaction without wiring together a separate browser stack.
Using TinyFish with Orthogonal
TinyFish is available through the same Orthogonal SDK your agents already use. One Orthogonal key gives you access to web automation infrastructure alongside the rest of your agent API stack.
Run a Web Agent
Use TinyFish Agent when the task is easier to describe as a goal than as a sequence of browser actions. Start an asynchronous run, then poll the returned run ID when your workflow needs the result.
import Orthogonal from "@orth/sdk";
const orthogonal = new Orthogonal({
apiKey: process.env.ORTHOGONAL_API_KEY,
});
const run = await orthogonal.run({
api: "tinyfish",
path: "/v1/automation/run-async",
method: "POST",
body: {
url: "https://scrapeme.live/shop",
goal: "Extract the first 2 product names and prices. Return JSON.",
},
});
console.log(run.data.run_id ?? run.data.id);Check Web Agent Run Status
Poll the run endpoint with the ID returned by run-async. Agents can continue other work while TinyFish navigates the site, then collect the result when the run is done.
const runId = "run_123";
const status = await orthogonal.run({
api: "tinyfish",
path: `/v1/runs/${runId}`,
method: "GET",
});
console.log(status.data);Generate Source-Backed Research
Use Research when a question needs evidence across several sources rather than one search result or one page extraction.
const report = await orthogonal.run({
api: "tinyfish",
path: "/v1/automation/run-research",
method: "POST",
body: {
query: "Compare web automation infrastructure options for AI agents",
mode: "standard",
},
});
console.log(report.data);Using x402 Protocol
TinyFish on Orthogonal supports x402 for native HTTP payments. Agents can pay for individual API calls with USDC, no separate TinyFish key required.
import { wrapFetchWithPayment } from "x402-fetch";
import { privateKeyToAccount } from "viem/accounts";
const account = privateKeyToAccount(
process.env.PRIVATE_KEY as `0x${string}`
);
const fetchWithPayment = wrapFetchWithPayment(fetch, account);
const response = await fetchWithPayment(
"https://x402.orthogonal.com/tinyfish/v1/automation/run-async",
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
url: "https://scrapeme.live/shop",
goal: "Extract product names and prices. Return JSON.",
}),
}
);
const data = await response.json();
console.log(data);Using MPP
TinyFish also works through MPP, the open standard for machine-to-machine payments co-authored by Tempo and Stripe. Agents can pay for TinyFish calls with stablecoins, cards, or Bitcoin on the same endpoint.
import { privateKeyToAccount } from "viem/accounts";
import { Mppx, tempo } from "mppx/client";
Mppx.create({
methods: [tempo({ account: privateKeyToAccount("0x...") })],
});
const response = await fetch(
"https://mpp.orthogonal.com/tinyfish/v1/automation/run-async",
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
url: "https://www.tinyfish.ai",
goal: "Summarize the main TinyFish product surfaces as JSON.",
}),
}
);
const data = await response.json();
console.log(data);The mppx client handles the 402 challenge, signs a credential with your wallet, and retries with proof of payment.
What Agents Can Do with TinyFish
Agents can use TinyFish when a workflow needs live web access, page extraction, source-backed synthesis, or browser actions. They can search for relevant pages, fetch clean content from known URLs, complete multi-step flows with a natural-language goal, generate cited research, or connect directly to a remote browser when a developer wants explicit control.
That shows up in practical workflows. A market research agent can gather current sources and produce a structured brief. A sales agent can inspect public account pages before writing outreach. A support agent can navigate vendor portals and collect status information. A data agent can extract clean content from pages where the HTML, scripts, and layout would otherwise become the job.
Why We Partnered with TinyFish
Agents need web access that is more reliable than a pile of browser scripts and more flexible than a single scraping endpoint. TinyFish gives builders a set of purpose-built surfaces for search, extraction, research, automation, and browser control. That lets an agent choose the right level of abstraction for each step instead of forcing every workflow through the same tool.
That fits Orthogonal well. We want agents to discover the right API, call it through one interface, and pay only for the work they use. TinyFish adds a web-native infrastructure layer for agent workflows that need to operate on the internet as it exists today.
Try It Today
Sign up for Orthogonal and get $10 free credits to try TinyFish and dozens of other APIs. One key, hundreds of APIs, pay per request.