About FetchIndex

The AI web-data hub: independent price comparisons for scraping APIs, proxies, browsers and search APIs.

FetchIndex is an independent price comparison for services that AI agents and apps use to get web data. Prices come from each vendor's official public pricing page and are normalized so different pricing models can be compared. We show our formulas, our assumptions and the gaps. No vendor has paid for placement. FetchIndex has an affiliate relationship with Firecrawl (it may earn a commission if you buy through a labelled affiliate link); that relationship does not change prices, rankings or caveats, and rankings remain rule-based. See the disclosure.

Operator: FetchIndex · Contact: [email protected]

---

Methodology

FetchIndex methodology

Dataset version 2026.10.16 · schema 1.0 · prices fetched 2026-10-16 (PT).

FetchIndex compares what services for AI agents and apps charge for web data: scraping APIs, proxies and unblockers, browser infrastructure, and search/SERP APIs. This page explains exactly how every number on the site is produced, so you can check it and so you know what it does not tell you.

What this is, and is not

• It is a price and packaging comparison built from each vendor's official public pricing page (or the official documentation page the pricing page points to).
• It is not a quality test. We have not measured success rates, speed, data accuracy or support. A cheaper price per 1,000 requests can still cost more if more requests fail or need retries.
• It is not a quote. Vendors change prices, run promotions and offer custom deals. Always confirm on the vendor's own page before you buy.

Where the data comes from

1. For each vendor we fetch the official pricing page (HTTP, or headless Chrome for pages that render prices with JavaScript). The URLs are listed per vendor in data/vendors.json under sources.
2. Where the pricing page leaves a unit unexplained (for example what one "credit" buys), we use the vendor's official documentation or FAQ and name that page.
3. We do not use affiliate dashboards, scraped third-party review sites, or vendor-supplied numbers that are not public. Third-party articles are never used as a price source.
4. Every vendor record carries fetched_at (the date we read the page). Every price shown on the site is labelled "last checked" with that date.
5. Text on vendor pages that addresses AI agents or tries to give instructions to automated readers is ignored. We only read prices and plan facts.

The normalized metric: "effective price per 1,000"

To compare services that bill in credits, requests, tokens, searches or hours, we convert published numbers into one comparable figure per use case:

Formula

usd = price_usd / quantity * per_request * (1000 for per-1,000 units, 1 otherwise)

• price_usd is a published price: a plan fee, a pack price, or a published per-unit rate.
• quantity is how many units that price buys (credits, requests, tokens, hours, GB).
• per_request is how many of those units one request consumes, as published (for example 5 credits for a JS-rendered page).

Each entry in data/vendors.json stores calc.price_usd, calc.quantity and calc.per_request plus a human-readable formula. scripts/validate.py recomputes every value from those inputs and fails if any stored number disagrees. Values are rounded to 4 decimals.

Assumptions we make

• Full utilisation of the plan. A plan's effective price assumes you use every included credit or request each month. If you use half, your real price per request is double. Unused credits generally expire.
• Included allowance only. Rows labelled "(overage)" show the published extra-usage rate instead, and are never mixed into plan averages.
• Billing cadence is explicit. Many vendors show an annual-billed monthly price. We keep monthly-billed and annual-billed rows separate (billing = monthly, annual, payg or prepaid). Where a vendor publishes only one, we use only that one and say so; we never infer the other.
• List price. Promotional coupons and first-deposit matches are noted but not used.
• Taxes excluded. VAT or sales tax are not included.

Confidence labels

• published : every input is a number published by the vendor (including the credit multiplier).
• component : the number is a real published rate for one billable component (for example a proxy or unblocker request) but other charges (compute, bandwidth, the scraper that calls it) are excluded. Treat as a floor.
• assumption : at least one input is our assumption (for example tokens per page, or a vendor's own rule-of-thumb for browser time). The assumption is written on the entry and shown next to the number. These are never used for "cheapest" rankings unless the reader opts in.

What we leave as null

A field is null (shown as "not published") when the vendor does not state it on the pages we checked: for example Firecrawl's monthly-billed price for plans above Hobby, ScraperAPI's JS-rendering credit multiplier, ZenRows' top-up price, Apify's per-page cost (it is set per Actor), Oxylabs' per-request Web Unblocker cost (it bills per GB). We would rather show a gap than invent a number. Each vendor page has a "What we could not verify" box.

Verification status

• Full: the plan prices, included quantities and published overage/pay-as-you-go rates for the vendor's core use case were captured from official pages, and at least one normalized metric was computed from published numbers only.
• Partial: at least one material component is unpublished, ambiguous or per-item (listed on the vendor page). Partial vendors are still shown, with the gaps stated.

MCP / agent support

"MCP supported" is only marked true when an official vendor page or an official repository under the vendor's own organisation mentions an MCP server. Otherwise it is null (not confirmed), never false by default.

Rankings and "cheapest tool for X"

The /api/cheapest.json feed and the on-site guide choose the lowest published effective price per use case among entries whose required monthly spend is at or below a stated budget. component rows are shown but flagged; assumption rows are excluded by default. Cheapest is not the same as best; read the vendor page.

Change tracking

scripts/refresh.py re-fetches the pages, stores a dated snapshot under data/snapshots/YYYY-MM-DD/, checks that the numbers we rely on still appear on each page (checks in the data), diffs numeric text against the previous snapshot, diffs the structured data, and writes findings to data/changelog.json, which feeds the Price change log page. A human then edits the facts. The script does not silently rewrite prices.

Cost calculator and volume tables

The calculator (/calculator/), the "alternatives" and "best for" pages and the extra comparison pages estimate a monthly bill for N requests from the same normalized entries, using one rule set (scripts/calc_engine.py, mirrored in site_src/calc.js; scripts/test_calc.py checks that both give identical results).

• Plan with an included allowance: cost is the plan fee while N is within the allowance (included quantity divided by credits per request). Above it we add the vendor's published overage rate for that plan and request type. If no overage rate is published, that plan cannot serve N and the next plan is considered.
• Pay as you go and prepaid packs: N divided by 1,000 times the published rate.
• Monthly minimum or prepaid spend with a per-1,000 rate (for example commitment tiers): the minimum buys spend divided by rate requests. Usage beyond that is not assumed to be billable at the same rate.
• Cheapest covering plan wins, per vendor. Annual-billed plans are shown as the monthly equivalent and labelled; they can be excluded.
• Partial data is never ranked with published prices: component-only rates, stated minimums ("lower bound") and assumption-based rows appear in a separate table. A vendor with no usable published price for the request type, or whose largest modelled plan is below N with no overage, is listed as "not enough data".
• Free tiers are listed but not subtracted. Taxes, proxies, CAPTCHA and add-ons are excluded unless a row says otherwise.

Independence

No vendor paid for placement, reviewed their entry before publication, or supplied data. FetchIndex has an affiliate relationship with Firecrawl and may earn a commission if you buy through a clearly labelled affiliate link. It does not change prices, rankings, ordering or caveats, and rankings remain rule-based. Every other link goes to an official vendor URL, and a plain official Firecrawl link always sits beside the affiliate one. See the affiliate and sponsor disclosure page.

Corrections

If you spot a wrong or stale number, tell us ([email protected]) and include the vendor URL. We correct errors and note the correction in the change log.