TinyFish is one of the strongest AI web agents available for dynamic, multi-step, and login-protected websites, but it is not the best tool for every scraping job. It performs well when a task requires reasoning, navigation, and structured extraction from a live site.
It is less efficient for high-volume crawling of static HTML pages, where traditional frameworks cost far less per page.
TinyFish is a web agent platform built by TinyFish Inc., a company founded in 2024 and led by co-founder and CEO Sudheesh Nair with CTO Mark Peng. The company raised $47 million in a Series A round led by ICONIQ Capital in August 2025, with participation from USVP, Mango Capital, and MongoDB Ventures. Its product line now includes four APIs: Agent, Search, Fetch, and Browser.
The Agent API is the core offering, and it accepts a URL plus a plain-English goal, then returns structured JSON.
This review evaluates TinyFish across seven attributes: extraction quality, dynamic site handling, bot-protection resistance, setup difficulty, pricing, documented limitations, and competitive position against Playwright, Scrapy, Browserbase, and Firecrawl.
The verdict at the end names who should adopt it and who should skip it. If the concept itself is new, the background guide on AI Web Scraping explains how agent-based extraction differs from selector-based scripts.
What Is TinyFish and What Does It Actually Do?
TinyFish is enterprise infrastructure for AI web agents that navigate websites, authenticate, extract data, and return structured output through a single API call.
The platform replaces the traditional pipeline of browser scripts, proxy pools, CAPTCHA handling, and LLM parsing with one hosted service.
The product exposes four distinct APIs, each solving a separate problem:
| API | Function | Price | Rate limit |
|---|---|---|---|
| Search | Returns ranked results with titles, snippets, URLs | Free | 30 requests/min |
| Fetch | Returns clean page text, renders JavaScript | Free | 150 URLs/min |
| Agent | Executes a natural-language goal on a live site | $0.016 per step | 2 concurrent runs |
| Browser | Returns a CDP/WebSocket URL for Playwright control | $0.002 per minute | 5 concurrent sessions |
The Agent API is the reason developers evaluate TinyFish. A single request contains two meaningful fields: url and goal. The agent then decides which elements to click, which forms to fill, and which values to return. Three endpoints control execution style: /run blocks until completion, /run-async returns a run ID for polling, and /run-sse streams live events in the order STARTED → STREAMING_URL → PROGRESS → COMPLETE.
Named customers include DoorDash, Grubhub, ClassPass, The Zebra, and Digital Garage in Japan, according to testimonials published on the TinyFish website. Vendor-published testimonials are marketing material, so they indicate deployment scale rather than independent validation.
How Does the TinyFish AI Web Agent Work?
The TinyFish agent splits web tasks into a reasoning layer and an execution layer, which is the architectural decision that separates it from screenshot-loop agents. TinyFish engineers state that only 20–30% of steps in a typical workflow require genuine reasoning, such as interpreting an unusual layout or choosing between two valid paths.
The remaining 70–80% of steps are mechanical: clicking date pickers, selecting dropdown values, submitting forms, and paginating. TinyFish routes those actions to small, task-specific models trained on web interaction patterns. These models respond in milliseconds and return the same action for the same input.
Three layers operate together during a run:
- Reasoning layer — uses large models for ambiguous decisions
- Execution layer — uses small deterministic models for mechanical actions
- Infrastructure layer — manages proxy routing, geographic distribution, and bot-check handling
This structure addresses compounding error, the central failure mode of long web workflows. At 95% per-step accuracy, a 3-step task succeeds 86% of the time, while a 10-step task succeeds only 60%. At 90% per-step accuracy, that same 10-step task drops to 35%. Reducing the number of stochastic steps raises end-to-end reliability more than upgrading the underlying model does. The same reliability logic applies across AI Agent Use Cases for Business, where a single broken step invalidates an entire workflow.
How Good Is TinyFish at Extracting Structured Data?
TinyFish scored 89.9% on the Online-Mind2Web benchmark and 81.9% on the hard-task subset, according to results the company published in February 2026. TinyFish’s benchmark contains 300 tasks across 136 live websites, three difficulty levels, and a judge that agrees with human evaluation 85% of the time.
Comparative hard-task scores on the same benchmark:
- TinyFish: 81.9%
- OpenAI Operator: 43.2%
- Claude Computer Use: 32.4%
- Browser Use: 8.1%
The 16-point gap between easy and hard tasks matters more than the headline number. Systems that drop 50 points or more between difficulty tiers were flattered by short tasks. TinyFish also published all 300 execution traces, including every failure, in a public spreadsheet. Published failure data is rare among agent vendors and allows independent verification of the claim.
Extraction quality depends heavily on goal quality. TinyFish documentation reports that specific goals complete 4.9x faster and return 16x less unnecessary data than vague goals for the same task. A goal such as “get the products” produces inconsistent field names. A goal that specifies field names, data types, null handling, and guardrails such as “do not proceed to checkout” produces stable JSON. Passing an output_schema guarantees typed fields. For more information about benchmarks, you can visit this page. There you’ll find any benchmarks.
Structured output compared with traditional parsing
Traditional scrapers extract raw HTML and require a separate parsing stage. TinyFish returns JSON directly from the agent run. Teams that currently maintain separate parsing layers can compare that approach against the options in this guide to Open Source Models and Tools for Extracting JSON Data, and against document-focused pipelines such as the Best API for PDF Data Extraction.
Can TinyFish Handle JavaScript-Heavy and Dynamic Websites?
TinyFish handles JavaScript-heavy and dynamic websites without additional configuration, because every Agent run executes inside a real browser session. Content that appears only after multiple JavaScript events fire becomes available to the agent, which removes the need for manual wait conditions and selector timing logic.
Three dynamic-site behaviors are covered by default:
- Client-rendered content loads before extraction begins
- Infinite scroll and pagination proceed as numbered goal steps
- Cookie banners and modals close when the goal instructs the agent to dismiss them
The Fetch API also renders JavaScript when needed and returns clean extracted text, which makes it a lower-cost option for known URLs that require rendering but no interaction. Failed fetches are not charged.
One constraint applies to every Agent run: the approximate timeout is 5 minutes. Long workflows must be split into smaller runs, which adds orchestration work back to the developer for very deep flows.
Can TinyFish Bypass Bot Protection and Access Authenticated Sites?
TinyFish handles many bot checks at the infrastructure layer, but enterprise-grade protection systems still cause documented failures. The platform offers two browser profiles: lite is the default, and stealth enables deeper infrastructure-level handling for sites that block standard automation.
Residential proxies are included in the step price at no extra charge, with country routing available for US, GB, CA, DE, FR, JP, and AU. That inclusion removes a separate vendor relationship, although it also removes fine-grained pool control. Teams comparing proxy types can review What Are Residential Proxies and Data Center Proxies vs Residential Proxies before deciding whether bundled proxies meet their needs.
The failure data is specific. Of 40 failed benchmark tasks, 12 failures came from bot blocks, and 8 of those came from apartments.com alone. Four failures came from unsupported UI widget types, and 24 came from edge cases. TinyFish also documents an auto-reconfiguration behavior: on a re-run of a blocked Kaggle task, the system switched proxies and completed successfully without human input.
Authentication is supported in three ways. Credentials can be passed inside the goal text, stored in Vault Credentials, or persisted through Browser Profiles that reuse authenticated sessions across runs. Vault Credentials is the appropriate choice for production, since credentials inside goal text appear in run logs.
Blocking behavior is not unique to TinyFish. Any automation stack encounters it, as explained in Prevent IP Bans During Web Scraping and Why CAPTCHAs Appear When You Use a VPN.
How Easy Is TinyFish to Set Up?
Setup requires an API key and a single HTTP request, which makes TinyFish faster to start than any self-hosted browser stack. Account creation at agent.tinyfish.ai requires no credit card and includes free starting credit.
The setup sequence contains four steps:
- Create a free account and generate an API key
- Export the key as the
TINYFISH_API_KEYenvironment variable - Send a curl request to
/run-ssewith a URL and a goal - Install the Python or Node SDK for production error handling
Integration surfaces include a REST API, Python and Node SDKs, a CLI, an MCP server for Claude and Cursor, and an n8n node for no-code workflows. The MCP and n8n options extend the tool to non-programmers, which aligns with the broader shift described in What Is No-Code Automation.
The COMPLETED status trap
One documented behavior deserves attention before production use. A COMPLETED status means the infrastructure worked, not that the goal succeeded. Two failure layers exist: infrastructure failures return FAILED with an error code and category, while goal failures return COMPLETED with result.status = "failure" and a reason field. Code that checks only the outer status will silently record empty results across a batch of URLs. Production code must check both layers.
Requests through /run cannot be cancelled. Runs created through /run-async or /run-sse can be cancelled with a POST to /v1/runs/{id}/cancel.
How Much Does TinyFish Cost?
TinyFish charges $0.016 per Agent step and $0.002 per Browser minute, while Search and Fetch cost $0.00. A step equals one action on a live website, such as a page load, click, form fill, or scroll. The step price includes browser execution, residential proxies, LLM inference, anti-bot handling, and storage of screenshots and logs.
Typical step consumption by task type:
- Single-page extraction: 2–5 steps
- Filtered search and extraction: 5–10 steps
- Login, navigate, and extract workflow: 10–20 steps
A 15-step authenticated workflow therefore costs about $0.24 per run at the published rate. One thousand such runs cost roughly $240, which is expensive relative to raw HTML crawling and inexpensive relative to an engineer maintaining a brittle script.
Two pricing details require caution. First, the pricing page now presents a wallet-funded, pay-as-you-go model with no plans and no monthly minimum, while older TinyFish blog posts reference a $15/month Starter plan with 1,650 steps and 10 concurrent agents, plus a Pro tier at $0.012 per step with 50 concurrent agents. The pricing structure has changed at least once during 2025–2026, so the live pricing page is the only reliable source. Second, default concurrency on pay-as-you-go is only 2 Agent runs and 5 Browser sessions, which limits large batch jobs without an enterprise contract. Rate limits on the free Search and Fetch tiers also apply, a constraint worth understanding through API Rate Limiting.
What Are the Main Limitations of TinyFish?
TinyFish has six limitations that affect purchase decisions, several of which the company documents itself.
- Cost per page is high for static sites. A 3-step extraction costs about $0.048, while a Scrapy request costs a fraction of a cent.
- Compliance certification is incomplete. TinyFish holds ISO 27001 but has not published SOC 2 or HIPAA certification, which blocks some regulated buyers. Teams with strict requirements should review what is SOC 2 compliance.
- Low-level control is reduced. Developers who need to control every interaction must fall back to the Browser API and write Playwright code.
- Aggressive protection systems still block runs. Benchmark data confirms 12 of 40 failures came from blocks.
- The 5-minute run timeout constrains deep workflows. Long processes need manual splitting.
- Default concurrency is low. Two concurrent Agent runs limit throughput until plans are upgraded.
Legal exposure remains the operator’s responsibility regardless of the tool. Reviewing Is Web Scraping Legal and Is Scraping Zillow Legal before deployment reduces that risk.
How Does TinyFish Compare With Playwright, Scrapy, and Browserbase?
TinyFish competes on outcome delivery, while Playwright, Scrapy, and Browserbase compete on control and cost per page. The comparison table below maps each tool to its strongest scenario.
| Tool | Model | Best use case | Main weakness |
|---|---|---|---|
| TinyFish | Goal-based agent | Dynamic, authenticated, multi-step tasks | Cost per page, low default concurrency |
| Playwright | Local browser library | Fine-grained interaction control | Selector maintenance, infrastructure work |
| Scrapy | Async crawling framework | High-volume static HTML crawling | No JavaScript rendering by default |
| Browserbase | Managed cloud browsers | Existing Playwright code in the cloud | Orchestration and AI logic remain yours |
| Firecrawl | Crawl and extract API | Feeding clean content to LLMs | Weaker on complex interactive flows |
Three practical differences separate TinyFish from Browserbase, its closest architectural rival. Browserbase creates a new session per request with roughly 5–10 seconds of setup, while TinyFish reports cold start under 250 ms. Browserbase meters browser hours, proxy bandwidth, search calls, fetch pages, and your own LLM spend separately, while TinyFish meters one unit. Browserbase requires you to build agent logic in Stagehand or your own framework, while TinyFish includes reasoning in the product. These comparisons come from TinyFish’s own competitive blog post, so treat the framing as vendor-sourced while the underlying architectural facts remain verifiable.
Cost discipline favors the older tools for simple work. Scrapy remains the cheaper choice for large static crawls, as covered in Scrapy in Python, and Selenium Web Scraping still fits teams with existing selector-based suites. Managed endpoints described in this Web Scraping API guide sit between the two extremes, and vertical products such as the Best Amazon Scraping APIs beat general agents on single-domain reliability.
Who Should Use TinyFish and Who Should Not?
TinyFish fits five groups clearly:
- AI developers building agents that need live web access alongside options from Free AI APIs for Developers
- Data engineers extracting structured records from dynamic dashboards
- Startup teams automating repetitive workflows without a dedicated infrastructure engineer
- Analysts monitoring prices, listings, and availability across many sites
- Non-technical operators using the n8n node or MCP server
TinyFish is the wrong choice for three groups: teams crawling millions of static pages where cost per page dominates, engineers who require step-level browser control, and organizations that mandate SOC 2 or HIPAA certification today.
Frequently Asked Questions
Is TinyFish the best AI agent for web scraping?
Yes, for dynamic and authenticated multi-step tasks. Its 90% Online-Mind2Web score and 81.9% hard-task score exceed published results from OpenAI Operator, Claude Computer Use, and Browser Use, and the full failure data is public.
Is TinyFish free to use?
Partly. Search and Fetch cost $0.00 on all accounts, and new accounts receive free starting credit, but Agent steps and Browser minutes are billed once that credit is consumed.
Can TinyFish scrape sites behind a login?
Yes. Credentials can be passed in the goal, stored in Vault Credentials, or persisted through Browser Profiles that reuse authenticated sessions.
Does TinyFish replace Playwright completely?
No. Playwright remains necessary for step-level control, and TinyFish’s own Browser API exists specifically so developers can drive Playwright or CDP directly.
Is TinyFish cheaper than Scrapy for large crawls?
No. Scrapy runs on your own compute at a fraction of a cent per request, while TinyFish bills $0.016 per step, making it more expensive for static high-volume crawling.
Does TinyFish handle CAPTCHAs and bot protection reliably?
Partly. The stealth browser profile and residential proxies clear many checks, but 12 of 40 documented benchmark failures came from blocks, including 8 on apartments.com.
Is a COMPLETED status proof that the task succeeded?
No. COMPLETED confirms the infrastructure ran, so production code must also check result.status for goal-level failure.
Is TinyFish suitable for regulated industries today?
No, in most cases. The platform holds ISO 27001 but has not published SOC 2 Type 2 or HIPAA certification, which many regulated buyers require.
Conclusion
TinyFish is currently the strongest general-purpose AI web agent for complex, interactive, and authenticated websites, and the published Online-Mind2Web traces support that position with verifiable evidence rather than marketing claims. The single-meter pricing model, free Search and Fetch endpoints, included residential proxies, sub-250 ms cold start, and 10-minute setup path make it the fastest way to move a web workflow into production without building browser infrastructure.
The tool is not a universal replacement. Scrapy wins on cost for static crawls, Playwright wins on control, and Browserbase wins for teams with existing automation code and the engineers to maintain it. TinyFish also carries real constraints: a 5-minute run timeout, two concurrent runs on pay-as-you-go, incomplete compliance certification, and documented failures against the most aggressive protection systems.
The practical recommendation is to test rather than to commit. Run one workflow that currently consumes engineering time, measure step count and success rate against your real target sites using the free starting credit, then compare total cost against your existing stack. Teams that spend more on script maintenance than on data volume will likely see a net gain. Teams that scrape simple pages at scale will not.
You May Also Like
Web ScrapingPython vs R for Data Analysis: Which Language is Best for You?
AI Tools10 Best PDF Extraction APIs for Text, Tables, OCR, and Structured Data
Web ScrapingWhat Is AI Web Scraping? A Complete Guide to AI-Powered Data Extraction
Web ScrapingScrapy in Python: A Practical Guide to Web Scraping
Web Scraping10 Best Open-Source Models and Tools for Extracting JSON Data
AI Tools15 Best Free AI APIs for Developers: Free Tiers, Credits, and Limits Explained
AI Technology32 Best Automated Business Ideas for Passive Income in 2026
AI TechnologyChatGPT API Alternatives for Developers: 12 OpenAI API Options
AI Technology