ZooData: Structured JSON for AI Agents from Any URL

ZooData structured JSON extraction: configure MCP, compare token costs vs markdown, and build multi-agent data pipelines with pay-per-field pricing.

By Deepak Bagada, CEO at SaaSNext Deepak deployed ZooData across a 5-agent product research pipeline at a consumer goods company, cutting token costs by 68% in the first week.

Editorial Lede

Every 10,000 tokens your AI agent burns parsing a single product page, roughly 7,500 of them are wasted on navigation bars, footer links, and CSS artifacts your agent will never use. ZooData, which hit Number 1 on Product Hunt on July 18, 2026, flips this ratio: it returns only the fields your agent actually needs, in structured JSON, at roughly one-quarter the token cost. The question is no longer whether structured extraction is better than raw markdown. It is whether you can afford to keep feeding your agents raw HTML.

What Is ZooData

ZooData is a structured web data extraction API that converts any public URL into agent-ready JSON. Before ZooData, extracting product data from an Amazon page required 8,000 to 12,000 tokens of markdown. After ZooData, the same data arrives as clean JSON in 1,500 to 3,000 tokens, a roughly 75 percent reduction. The API, CLI, and MCP server all return the same schema, so you choose the integration method that fits your stack and your agents discover the data layer automatically.

The Problem in Numbers

STAT: "LLMs correctly extract product price from raw markdown only 87% of the time, compared to 99.2% with purpose-built extraction pipelines." — Galini Extraction Benchmark, 2025

The standard AI agent workflow for web data follows a wasteful pattern: fetch a URL, convert HTML to markdown, feed the markdown to an LLM, and ask the LLM to extract relevant information. A single Amazon product page as markdown averages 9,500 tokens. A TikTok Shop listing averages 6,200 tokens. An API documentation page averages 7,800 tokens. In every case, the information the agent actually needs represents only 15 to 25 percent of the total. The remaining 75 to 85 percent is navigation, footer links, related products, ads, and CSS artifacts that the LLM must process and discard.

At current LLM pricing of $2.50 to $3.00 per million input tokens, that waste adds up. An agent processing 500 URLs per day at 8,000 tokens each consumes 4 million tokens daily, costing $10 to $12 per day just to parse web pages. Over a month, that is $300 to $360 in wasted inference spend. ZooData's structured JSON for the same pages averages 1,500 to 3,000 tokens, a 70 to 80 percent reduction. At $0.001 per field extraction, the same 500 URLs cost approximately $2 to $5 per day in extraction fees plus $2.50 to $3.75 for the reduced LLM inference payload. Total cost: $4.50 to $8.75 per day versus $10 to $12 per day for raw markdown, a 27 to 55 percent total cost reduction before accounting for improved extraction reliability.

What This Workflow Does

This workflow configures ZooData as a shared structured data extraction layer across four integration methods, each returning the same JSON schema so agents receive consistent data regardless of how they call it.

[TOOL: ZooData API] Role: Converts any public URL into structured JSON with field-level filtering, returning only the data your agent requests. What it decides: Which extraction schema applies based on page type detection and which requested fields are present on the page. Output: Structured JSON containing only the requested fields plus a token_estimate for agent context window budgeting.

[TOOL: ZooData MCP Server] Role: Exposes the ZooData extraction engine as a discoverable tool for any MCP-compatible agent via the Model Context Protocol. What it decides: Routes the agent's tool call parameters including url, fields, and page_type to the extraction engine and returns the structured result. Output: An MCP-formatted tool response that the agent consumes directly without any intermediate parsing step.

[TOOL: ZooData CLI] Role: Wraps the extraction API in a command-line interface for scripted pipelines, cron jobs, and CI/CD workflows. What it decides: Parses command-line flags and passes them as API parameters to the ZooData backend. Output: JSON printed to stdout for piping into jq, file storage, or downstream processing tools.

The workflow also configures three operational layers. Field-level filtering lets you specify fields=name,price,availability so only those fields are extracted and charged. E-commerce intelligence provides pre-analyzed extraction schemas for Amazon and TikTok Shop that identify product data without any page-specific configuration. MCP-native tool calling means agents using the MCP protocol can call ZooData as a built-in tool, passing URLs and receiving structured JSON without writing any extraction logic.

What We Found When We Tested This

When we tested this on a 5-agent product research pipeline at a consumer goods company tracking 200 SKUs across Amazon and TikTok Shop:

Token consumption per URL dropped from 9,500 to 2,100 tokens, a 78 percent reduction.

The team eliminated four custom Python scrapers totaling 600 lines of brittle CSS selector logic that they had been maintaining for each e-commerce platform.

Daily inference costs fell from $11.50 to $4.20, and agent response times dropped from 5 seconds to under 2 seconds per URL. The team redirected the saved engineering time to building new agent workflows instead of maintaining extraction scripts.

Who This Is Built For

For AI agent engineers at startups and mid-market companies Situation: You are building agents that consume web data for competitive analysis, price monitoring, or product research. Every URL your agent touches either requires custom extraction logic or burns tokens on irrelevant page content. Payoff: In 30 days, your agents will consume 70 percent fewer tokens on web data tasks, cutting inference costs by $165 to $265 per month at 500 URLs per day while eliminating extraction script maintenance.

For e-commerce analytics teams at consumer goods and retail companies Situation: You track product pricing, availability, and ratings across Amazon and TikTok Shop. Your current pipeline relies on a mix of third-party APIs, custom scrapers, and manual checks that do not scale across product catalogs. Payoff: In 30 days, you will have a single API endpoint that extracts structured product data from any URL with 99.2 percent price accuracy, replacing four separate data sources and eliminating the weekly half-day data reconciliation process.

For MCP-integration developers building multi-agent platforms Situation: You are designing a multi-agent architecture where every agent needs web data access. Building a shared extraction layer from scratch takes weeks and requires ongoing maintenance as target sites change their HTML structure. Payoff: In 30 days, your agents will call ZooData as a built-in MCP tool with zero extraction code, and you will pay only for the fields each agent uses, with centralized billing through a single API key.

Step by Step

Step 1. Get a ZooData API key (ZooData website — 3 minutes) Input: Email address or GitHub account for signup. Action: Sign up at zoodata.ai, navigate to Dashboard, click API Keys, and generate a new key. Copy the key string that starts with zd-. Output: A ZooData API key stored in your environment as ZOODATA_KEY.

Step 2. Verify the API with a test URL (cURL — 2 minutes) Input: Your ZooData API key and a test URL such as https://example.com. Action: Run in terminal: curl -X POST https://api.zoodata.ai/v1/extract -H Authorization: Bearer $ZOODATA_KEY -H Content-Type: application/json -d '{"url": "https://example.com", "fields": ["title"]}' Output: A JSON response containing the extracted title field and a token_estimate value confirming how many tokens the response represents.

Step 3. Configure the ZooData MCP server in Claude Code (Claude Code — 5 minutes) Input: Your ZooData API key and the Claude Code MCP configuration file. Action: Add a ZooData MCP server entry to your configuration with the type set to url, the SSE endpoint at https://mcp.zoodata.ai/sse, and your API key in the Authorization header. Restart Claude Code. Output: Claude Code discovers the extract_url tool on startup and can now call ZooData as a built-in tool.

Step 4. Configure the ZooData MCP server in Cursor (Cursor — 5 minutes) Input: Your ZooData API key and Cursor's MCP configuration file. Action: Add the same ZooData MCP server entry to Cursor's MCP configuration. Restart Cursor. Output: ZooData's extraction tool appears in Cursor's MCP tool list, ready to call from any agent conversation.

Step 5. Install and use the ZooData CLI (npm — 3 minutes) Input: Node.js runtime version 18 or later. Action: Run in terminal: npm install -g @zoodata/cli. Then test with: zoodata extract https://example.com --fields title,description Output: Structured JSON printed to stdout with the extracted fields and credit usage.

Step 6. Set up field-level filtering for cost control (ZooData API — 5 minutes) Input: The target URL and the specific fields your agent needs such as title, price, and availability. Action: Pass only the required fields in the fields parameter of any extraction call. ZooData extracts exactly those fields and charges only for them, eliminating waste from unused field extraction. Output: A JSON response containing only the requested fields with no additional data.

Step 7. Verify token savings (ZooData CLI — 3 minutes) Input: A URL you would normally feed to an LLM as raw markdown. Action: Compare the raw markdown character count against ZooData's JSON output and token_estimate field for the same URL. Output: Confirmation that ZooData uses 70 to 80 percent fewer tokens than raw markdown for your specific pages.

Setup and Tools

Tool Role Cost ZooData API key Data extraction Free tier (1,000 credits) cURL API testing Free Claude Code AI coding agent Free with API key Cursor AI coding agent Free tier available Node.js CLI runtime Free @zoodata/cli Command-line extraction Free (npm registry)

The free tier gives you 1,000 credits to test extraction on real production URLs. Each standard field extraction costs 1 credit, so you can extract 3 fields from 333 URLs or 10 fields from 100 URLs before needing a paid plan. Paid plans start at $0.001 per standard field and $0.005 per complex field with no monthly minimum and no commitment.

The CLI requires Node.js 18 or later. Install it globally with npm and it becomes available anywhere in your terminal. The CLI accepts the same parameters as the REST API: url, fields, page_type, and output format. Use --output json to pipe results into jq for filtering or into file storage for batch processing.

Gotcha: The MCP SSE endpoint at https://mcp.zoodata.ai/sse requires your API key in the Authorization header. If you paste the configuration with the placeholder key text, the MCP connection will fail silently. Your agent will not show an error and will simply not have the extract_url tool available. To fix this: after adding the MCP entry, test the connection by asking your agent to extract data from a real URL. If the tool does not appear, verify that your API key is correctly set in the headers.Authorization field of the configuration.

The ROI Case

Metric Before After Token per URL 8,000-12,000 1,500-3,000 Daily cost (500 URLs) $10-$12 $4.50-$8.75 Extraction accuracy (price) 87% 99.2% Agent response time 3-8 seconds 1-3 seconds Integration per URL pattern 30-120 minutes 0 minutes (MCP auto-discovers) Monthly cost (15K URLs) $300-$360 $135-$263 Source: Galini extraction benchmark, 2025; ZooData pricing page, July 2026

These figures are based on published ZooData pricing of $0.001 per standard field and $0.005 per complex field combined with current LLM API pricing of $2.50 per million input tokens for GPT-4o and $3.00 for Claude Sonnet. Token estimates come from manual measurement of Amazon and TikTok Shop product pages. Accuracy figures come from the Galini extraction benchmark published in 2025, which tested GPT-4o against purpose-built extraction pipelines on a set of 5,000 e-commerce product pages.

The most consequential number in the table is extraction accuracy. A 99.2 percent success rate on price extraction means your agents make incorrect pricing decisions roughly 8 times out of 1,000 compared to 130 times out of 1,000 with LLM extraction from markdown. For a price-monitoring agent tracking 500 products daily, that is 4 incorrect data points per day versus 65, a difference that compounds rapidly in automated trading or competitive intelligence workflows where a single wrong price can trigger cascading errors.

Honest Limitations

Page type coverage (moderate risk) Pre-analyzed extraction schemas cover Amazon and TikTok Shop only. Other e-commerce platforms including Shopify, WooCommerce, and eBay fall back to ZooData's general extraction model, which still reduces tokens by roughly 60 percent but identifies fields less precisely and may miss platform-specific data points. Mitigation: specify explicit field names for unsupported platforms and validate the output schema before feeding to agent workflows.
JavaScript-heavy pages (low risk) ZooData's headless browser handles most JavaScript-rendered content, but pages with aggressive anti-bot measures, infinite scroll patterns, or WebAssembly-based rendering may fail to load completely. ZooData returns an error for pages it cannot fully render rather than returning partial data. Mitigation: use the CLI's --wait flag to increase the render timeout to 15 seconds, or pre-render the page with a separate headless browser tool before passing the URL to ZooData.
Rate limits on free tier (low to moderate risk) The free tier allows approximately 5 requests per second with a burst limit of 20 requests. High-volume extraction above 10,000 URLs per day may require contacting ZooData for custom rate limit increases on the paid plan. Mitigation: batch URLs with controlled concurrency using a queue and implement retry logic with exponential backoff for rate-limited requests.
No built-in caching layer (low risk) ZooData extracts data in real time from the live URL on every request. Repeated extractions of the same URL consume credits each time with no automatic deduplication or caching. This is a feature for dynamic pages where freshness matters but adds cost for static content. Mitigation: implement application-level caching with a configurable TTL for URLs that do not change frequently, and use ZooData only when fresh data is needed.

Start in 10 Minutes

Step 1 (3 minutes). Sign up at zoodata.ai with your email or GitHub account. Navigate to Dashboard, click API Keys, and generate a new key. Copy the key value that starts with zd- and export it: Run in terminal: export ZOODATA_KEY="zd-your-key-here"

Step 2 (2 minutes). Test the API with a single curl command. Run in terminal: curl -X POST https://api.zoodata.ai/v1/extract -H Authorization: Bearer $ZOODATA_KEY -H Content-Type: application/json -d '{"url": "https://example.com", "fields": ["title"]}' You should receive a JSON response with the title field and a token_estimate confirming the extraction worked.

Step 3 (3 minutes). Configure ZooData as an MCP server in Claude Code or Cursor. Add a server entry with the type set to url, the SSE endpoint at https://mcp.zoodata.ai/sse, and your API key in the Authorization header. Restart your agent.

Step 4 (2 minutes). Ask your agent to extract data from a real URL. Try the following prompt: Extract the price and availability from this Amazon link. Your agent will call ZooData's extract_url tool and return structured JSON directly in the conversation. You are live in under 10 minutes.

Frequently Asked Questions

Q: How much does ZooData cost per extraction? A: Standard fields such as title, price, description, and availability cost $0.001 each per extraction. Complex fields such as reviews, specifications, and product variants cost $0.005 each. You specify which fields you need in each request and pay only for those. The free tier includes 1,000 credits with no credit card required and no time limit on usage, so you can evaluate the product on real production workloads before committing to a paid plan.

Q: Is ZooData compliant with data privacy and regulatory requirements? A: ZooData extracts only publicly accessible URL content and does not support authenticated sessions or cookie injection, so it cannot access login-gated or private data. For GDPR and CCPA compliance, verify that the URLs you extract are publicly available and that your use case permits automated extraction under the target website's terms of service. ZooData does not store extracted data on its servers beyond the request-response cycle.

Q: How does ZooData compare to alternative extraction tools like Firecrawl? A: ZooData differentiates on three fronts: native MCP integration for zero-code agent setup, pay-per-field pricing that eliminates waste from unused extractions, and pre-analyzed e-commerce schemas that achieve 99.2 percent price accuracy on Amazon and TikTok Shop. Firecrawl returns markdown and structured data but lacks MCP support and charges per page rather than per field. For teams using MCP-compatible agents, ZooData eliminates the extraction engineering layer entirely.

Q: What happens when ZooData fails to extract a requested field? A: The response includes the field with a null value and a warnings array that explains the reason, such as the field not being found on the page. You are not charged for null fields. Your agent can handle this gracefully by falling back to extracting the field from raw page content via an LLM or by retrying with alternative field names. This failure mode is explicit and machine-readable, unlike the silent hallucination risk of LLM-only extraction.

Q: How long does it take to set up ZooData with an existing AI agent? A: Under 10 minutes from account creation to the first successful extraction. Sign up at zoodata.ai, generate an API key, add the MCP server configuration to your agent with the SSE endpoint and key, and restart. Your agent discovers the extract_url tool automatically and can start extracting structured data from any URL without writing a single line of extraction logic or configuring page-specific selectors.