StoreRouter vs. Apify
Indexed product data vs. scraping Actors.
StoreRouter answers search and parse from an index it keeps current: it detects changes on covered stores and re-crawls them, so you never schedule a crawler. One schema, as JSON or Markdown. Apify's E-commerce Scraping Tool collects records on demand from the URLs and keywords you give it.
- /v1/products/search
- /v1/products/parse
- JSON · Markdown
Evidence recorded September 23, 2026 · StoreRouter, formerly Octogen
| Capability | StoreRouter | Apify |
|---|---|---|
| Model | Hosted product index behind one API | Scraping Actor you configure and run |
| Discovery | search across covered catalogs | Keywords → search engines and marketplaces |
| Product detail | parse a URL into one shared schema | Actor records; field names vary by source |
| Freshness | Change detection keeps the index current; force a live parse when needed | As fresh as your last run; you schedule re-runs |
| Enrichment | Normalized attributes on indexed products | Optional AI-summary add-on |
| You operate | API calls | Actor runs and schedules, datasets, field mapping, search |
| Pricing | $2 / 1k parse · $14 / 1k search | Plan-dependent; per-result and add-on fees |
Fit
Which one fits
Choose StoreRouter when
your agent needs to search products across stores and read them in one schema, without operating crawlers, proxies or field mapping. StoreRouter runs crawling, change detection and extraction for covered catalogs.
Choose Apify when
you need configurable collection from sources StoreRouter doesn't cover, and you're prepared to run the Actors, store the datasets, and build the mapping and search layer yourself.
Recorded run · 2026-09-23
Search → parse → product detail
Two catalog-filtered search requests (q="leather bag", limit=2) against two covered fashion stores returned four product URLs. Index-only parse resolved all four.
We submitted one of them, the Savette Symmetry Shoulder Bag, to Apify's E-commerce Scraping Tool and compared the records field by field:
| Field | StoreRouter (indexed) | Apify (standard) |
|---|---|---|
| Description | Leather exterior and lining; turnlock closure; interior pocket | “bag” |
| Dimensions | ~10 × 6 × 2 in; 19–22 in strap drop | Not returned in this sample |
| Image URLs | 7 | 1 |
Apify also returned title, SKU and availability. The StoreRouter record adds the dimensions, strap drop and materials an agent needs to answer fit and capacity questions.
The run stops at the product record; we did not evaluate an agent's answer. Both searches were filtered by store and the products came from StoreRouter's index, so this is not a cross-catalog ranking or a coverage test.
Architecture
Where the work happens
- Discovery. StoreRouter
searchqueries one shared index across covered catalogs. Apify's tool also accepts keywords and collects results from search engines and marketplaces (Apify docs). - Product detail.
parseturns a product URL into the shared schema. Indexed products include normalized attributes and enrichment; on-demand results can be sparser and skip enrichment. - Freshness. StoreRouter watches covered stores for changes and re-crawls what changed, so the index tracks the live store without crawl schedules on your side. To bypass the index for one product,
parsewithresolutionMode: "on_demand_only"andonDemandCachePolicy: "refresh"forces a live read. With Apify, records are as fresh as your last run, and scheduling re-runs is yours. - Schema. Products, variants and attributes land in fixed fields, rendered as JSON or Markdown. Across our Apify samples the product name appeared as
nameortitle, prices as numbers or strings, and currency in different fields: mapping you would own.
With Apify you assemble the catalog, field mapping and search layer. With StoreRouter that layer already exists for covered catalogs. We did not benchmark search relevance or performance between the two.
Evaluation
Representation scores
We scored five products with our Product Representation Compare rubric: Sufficiency, Vividness and Searchability, each 1–10, with Quality = mean(Sufficiency, Vividness). StoreRouter Markdown averaged 8.4 Quality against 6.1 for both Apify profiles, and used more response tokens to do it.
| Five-product mean | StoreRouter Markdown | Apify standard | Apify + AI summary |
|---|---|---|---|
| Sufficiency | 8.4 | 5.8 | 5.8 |
| Vividness | 8.4 | 6.4 | 6.4 |
| Searchability | 7.8 | 5.6 | 5.6 |
| Quality | 8.4 | 6.1 | 6.1 |
| Response tokens (mean) | 1,135 | 254 | 774 |
| Parse effort | Trivial | Easy | Moderate |
- Sufficiency: the facts needed to understand the product.
- Vividness: how specifically the product is represented.
- Searchability: attributes in the product description. It does not measure Search API results.
- Parse effort: the work to read the response, not API runtime.
Five selected products, one unblinded evaluator. Exploratory representation judgments, not measured accuracy or completed agent tasks. Enrichment is derived and was not independently verified.
One product in detail: a dress
| Rubric axis | StoreRouter Markdown | Apify standard | Apify + AI summary |
|---|---|---|---|
| Sufficiency | 9 | 7 | 7 |
| Vividness | 9 | 7 | 7 |
| Searchability | 8 | 6 | 6 |
| Quality | 9.0 | 7.0 | 7.0 |
| Response tokens | 1,544 | 298 | 1,169 |
| Parse effort | Trivial | Easy | Moderate |
StoreRouter returned nine size-and-stock rows, eight image URLs, ratings and normalized attributes; it also repeated some attributes and had no detailed size chart. Apify's standard record kept useful material, color and fit prose, but returned one image and no size-and-stock matrix or ratings. The AI summary added prose without filling those gaps.
Token counts use tiktoken/cl100k_base. This dress is one of the five scored products; the mean table above is rounded.
Context: reading the merchant page directly
For scale, the same rubric applied to two full merchant product pages. These are separate products from the dress, so read them as the cost of ingesting raw PDPs, not as a matched result or an Apify-versus-merchant ranking.
| Rubric axis | Merchant PDP A · raw HTML | Merchant PDP B · rendered DOM |
|---|---|---|
| Sufficiency | 7 | 4 |
| Vividness | 7 | 6 |
| Searchability | 6 | 5 |
| Response tokens | 544.4K | 823.9K |
| Parse effort | Severe | Severe |
Token counts are whole page artifacts, not extracted records. They don't measure Apify's collection cost and shouldn't be averaged with the dress scores.
Separately, in the four-product run above, StoreRouter returned 4/4 known-indexed products and this Actor returned 2/4. The sample came from StoreRouter's index: it shows the value of an existing index for those URLs, not a coverage rate or proof that another Apify configuration would fail.
Before you build
Integration notes
- Are the stores I need covered?
searchonly spans covered catalogs; check catalog coverage for the stores your agent needs. A successfulparseof one URL doesn't make its store searchable. Coverage expands with request demand. That's the direction, not a guarantee for any given store today.- How fresh are price and availability?
StoreRouter detects changes on covered stores and picks them up, so the index stays in step with the live site and drift between the two is uncommon. Indexed responses come back without a storefront fetch. When an answer hinges on the current value, such as stock right before checkout, send
parsewithresolutionMode: "on_demand_only"andonDemandCachePolicy: "refresh"to force a live read.- What happens on an index miss?
parsecan resolve an uncovered URL on demand. That result can be sparser than an indexed product, skips enrichment, and doesn't make the store searchable. Handle misses and pending results in your integration.- What does it cost?
$2 per 1,000 parse requests and $14 per 1,000 search requests; only successful 2xx responses are billed (see pricing). Budget for misses, retries and downstream model tokens too. Our pilot did not measure end-to-end agent cost against Apify.
Give your agent every store.
Mint a key, send search a real shopping query, and parse the products your agent would recommend.
Observations
Recorded timings
StoreRouter: 11 successful index-only parse requests had a client-measured median of 265 ms (range 215–1,299 ms). No storefront fetch happened during those requests. On-demand parse may run live extraction and is outside these numbers.
Apify: the standard Actor run took 37.0 s for an 11-URL batch and returned 8 records; the AI-summary run took 70.8 s for the same batch, also 8 records. Run time is not time to first record. Records may arrive earlier, and existing datasets can be reused.
Different units: per-request time vs. per-batch run time. Not a matched latency benchmark or a speedup claim. Don't divide batch time by URL count to compare.
Observations
Pilot fees
The pilot used index-only parse, so it produced no StoreRouter invoice; the $2 / 1k parse price is the published rate.
| Apify profile | Observed fee | Per 1k submitted URLs | Per 1k returned records |
|---|---|---|---|
| Standard | $0.0487 | $4.43 | $6.09 |
| AI summary | $0.1087 | $9.88 | $13.59 |
Scaled from one 11-URL run that returned 8 records, including a run-start fee: not a quote for a 1,000-URL run. Apify's published rates vary by plan and add-ons, and some paid-plan base rates are below StoreRouter's parse price. Search pricing and full agent costs are outside this pilot.
Methodology
Scope and limitations
- Actor and settings.
apify/e-commerce-scraping-tool, build0.0.99, AUTO mode with additional properties enabled. Standard runs disabled AI summaries; the AI profile used Apify's default summary prompt. This evaluates that Actor and those settings, not every Apify Actor or custom workflow. - StoreRouter. Index-only
parsefor every response. - Cohorts. The representation pilot used 12 StoreRouter demo URLs; 11 returned indexed products and were submitted to Apify (the merchant-dead URL was not). The repeat-fetch diagnostic and the four-product search run are separate cohorts. All products were selected from StoreRouter sources, so none of this estimates coverage, and a missing record alone doesn't say why extraction failed.
- Scoring. One provider-aware evaluator. Image URLs were counted, not downloaded. Absent outputs got no score. No independent accuracy audit, Search API benchmark, coverage-expansion test or end-to-end agent cost study was run.
- Timings. Reused saved metadata; no new latency test. StoreRouter times are per-request client round trips. Apify times span Actor start to finish, excluding queueing and dataset download. Caches, geography and load were not controlled.
- Fees. Failed-call billing, subscription allocation and downstream model costs are excluded.
Repeated values
With identical Apify standard settings, the same dress URL returned CZK 3,400, then USD 114, with no proxy geography pinned; the record's field structure stayed the same. StoreRouter's indexed response stayed $114 with an unchanged body. This is a locale-consistency observation, not proof of an incorrect price or of StoreRouter's freshness.