StoreRouter vs. Zyte
A product index vs. extraction from the URLs you crawl.
Zyte API fetches any URL through its unblocking stack and, with automatic extraction, returns the page as a structured product, product list or category navigation. Finding the URLs, scheduling re-crawls and storing results stay with you. StoreRouter answers search and parse from a product index it keeps current across stores, in one schema, so your agent starts from a shopping query instead of a crawl.
- /v1/products/search
- /v1/products/parse
- JSON · Markdown
Evidence recorded November 6, 2026 · StoreRouter, formerly Octogen
| Capability | StoreRouter | Zyte |
|---|---|---|
| Model | Product index behind one API | Web scraping API: fetch and extract each URL on request |
| Scope | Covered ecommerce catalogs; other product URLs on demand | Any public web page |
| Discovery | search across covered catalogs | URLs you supply or crawl; a spider template can use each site's own search |
| Product detail | parse into one shared schema, from a verified per-store extractor | AI-extracted product with variants; custom fields via an LLM, billed per token |
| Freshness | Change detection keeps the index current; force a live parse | Live fetch on every request; you schedule re-crawls |
| Agent access | OAuth MCP, REST, CLI, TypeScript and Python SDKs | Hosted MCP with sign-in, REST, Python client, Scrapy integration |
| Pricing | $2 / 1k parse · $14 / 1k search | $0.13–$16.08 / 1k requests by site tier, plus $0.27–$1.07 / 1k to extract |
| Free tier | $5 credit every month | $5 credit for 30 days |
Fit
Which one fits
Choose StoreRouter when
your agent shops: it searches products across stores from a plain-language request, compares them on price, stock, materials and fit, and needs every store's products in the same fields without crawling, scheduling or maintaining extraction yourself.
Choose Zyte when
you run your own crawls: you know the sites and URLs, want any site or page type, need the lowest per-page price on easy sites, or already build on Scrapy and Scrapy Cloud, and you'll own scheduling, storage and search.
Overview
What each tool does
Zyte is a web scraping company: Zyte API handles bans, browser rendering and geolocation for any URL, Scrapy Cloud runs Scrapy spiders, and Zyte Data delivers managed datasets on a custom quote. Zyte API's automatic extraction turns a page into one of three e-commerce types: product (name, price, availability, brand, GTIN, images, description, additionalProperties and variants, each with its own price and availability), productList for listing pages, and productNavigation for category pages. customAttributes adds fields you define, filled by an LLM. Open-source e-commerce spider templates crawl a site from a start URL with these types.
StoreRouter keeps a product index across thousands of covered stores and keeps it current by detecting changes and re-crawling them. search takes a shopping query across stores and returns products; parse turns a product URL into the shared schema: variants, per-size stock, price, images, materials and normalized attributes. You call an API; crawling, unblocking and extraction are ours.
This page compares documented approaches. We have not benchmarked Zyte's extraction, coverage or latency against StoreRouter's.
Architecture
Where the work happens
- Discovery. Zyte API extracts from URLs you give it; it has no product search across stores. Its spider template can submit a query through each input site's own search box, which its docs note may not work on every site, and its web search returns pages, not products. StoreRouter
searchsends one query across covered catalogs and returns products. - Extraction. Zyte's
productcomes from one AI model applied to whatever page you send, which is why it works on any site. Its docs note that variants not visible on the page, and details that need extra requests, may be missing. StoreRouter writes and verifies an extractor for each covered store, so the same product returns the same record on every call. - Freshness. Every Zyte API request fetches the live page, and you choose when to re-crawl. StoreRouter answers from an index that tracks changes on covered stores, with no storefront fetch on an indexed answer;
parsewithresolutionMode: "on_demand_only"andonDemandCachePolicy: "refresh"forces a live read. - Agent workflow. Zyte's hosted MCP server exposes fetch, extraction and search tools such as
extract_from_browser, plus Scrapy Cloud job tools (Zyte MCP). The agent chooses URLs and render modes. StoreRouter's MCP exposes the product operations themselves:search_productsandlookup_product. - Reach. Zyte reaches nearly any public page, including sites StoreRouter doesn't cover and pages that aren't products. StoreRouter covers the catalogs in its index;
parsecan resolve other product URLs on demand, with sparser results and no enrichment.
Before you build
Integration notes
- What's a good Zyte alternative for structured e-commerce product data?
If you want to keep crawling yourself, other scraping APIs include Firecrawl, Oxylabs, Bright Data, ScraperAPI and Apify. If your agent needs to find products across stores and read them in one schema without running crawls, a product API fits instead: StoreRouter
searchandparse, or Channel3 for merged products with merchant offers.- How does pricing compare?
StoreRouter: $2 per 1,000 parse requests and $14 per 1,000 search requests; only successful 2xx responses are billed (see pricing). Zyte API charges per successful response by site difficulty tier, from $0.13 to $1.27 per 1,000 over HTTP and $1.01 to $16.08 with browser rendering, plus $0.27 to $1.07 per 1,000 for automatic extraction; monthly commitment plans from $100 lower those rates.
customAttributesadds LLM token charges (Zyte pricing).On easy sites, Zyte's per-page price is below StoreRouter's parse price; on hard, browser-rendered sites it's above. Add the crawl to find URLs, re-crawls to keep them current, storage and the search you'd build on top.
- How long does a request take?
Zyte's docs say plain HTTP requests usually return in under a second, browser-rendered responses commonly take 10–30 seconds, and some requests take tens of seconds. Automatic extraction uses browser rendering by default; extracting from the HTTP response is usually faster and cheaper. An indexed StoreRouter
parsedoesn't fetch the storefront: in our recorded runs, client-measured medians were about 0.3 s (StoreRouter vs. Firecrawl).- Can I use this inside an AI agent or LLM workflow?
Yes, both. StoreRouter's MCP server signs in with OAuth and works with Claude, Cursor and any MCP client; REST, a CLI and TypeScript and Python SDKs cover the rest (MCP docs). Zyte's hosted MCP server also signs in through the client and bills usage at Zyte API rates; its tools fetch and extract pages, so the agent decides which URLs to read.
- Can I use both?
Yes. Use StoreRouter for product search and detail across covered stores, and Zyte for crawling other sites, non-product pages and Scrapy projects.
Give your agent every store.
Mint a key, send search a real shopping query, and parse the products your agent would recommend.
Documentation reviewed · 2026-11-06
Sources and scope
This page compares documented approaches. We have not run a Zyte benchmark or established better record completeness, accuracy, coverage, freshness or latency.
- Automatic extraction: data types,
extractFrom, variant limits. - Product item reference:
productand variant fields. - Custom attributes: LLM-filled fields.
- Pricing and pricing docs: tiers, plans, extraction and LLM charges.
- Zyte MCP and optimizing requests: tools, sign-in, response times.
- Spider template search: search queries through each site's own search.
Prices are pay-as-you-go list rates on the review date.