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

StoreRouter and Apify at a glance
CapabilityStoreRouterApify
ModelHosted product index behind one APIScraping Actor you configure and run
Discoverysearch across covered catalogsKeywords → search engines and marketplaces
Product detailparse a URL into one shared schemaActor records; field names vary by source
FreshnessChange detection keeps the index current; force a live parse when neededAs fresh as your last run; you schedule re-runs
EnrichmentNormalized attributes on indexed productsOptional AI-summary add-on
You operateAPI callsActor runs and schedules, datasets, field mapping, search
Pricing$2 / 1k parse · $14 / 1k searchPlan-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:

Savette Symmetry Shoulder Bag: StoreRouter and Apify records
FieldStoreRouter (indexed)Apify (standard)
DescriptionLeather exterior and lining; turnlock closure; interior pocket“bag”
Dimensions~10 × 6 × 2 in; 19–22 in strap dropNot returned in this sample
Image URLs71

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 search queries one shared index across covered catalogs. Apify's tool also accepts keywords and collects results from search engines and marketplaces (Apify docs).
  • Product detail. parse turns 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, parse with resolutionMode: "on_demand_only" and onDemandCachePolicy: "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 name or title, 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 representation ratings
Five-product meanStoreRouter MarkdownApify standardApify + AI summary
Sufficiency8.45.85.8
Vividness8.46.46.4
Searchability7.85.65.6
Quality8.46.16.1
Response tokens (mean)1,135254774
Parse effortTrivialEasyModerate
  • 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

Representation scores for one dress
Rubric axisStoreRouter MarkdownApify standardApify + AI summary
Sufficiency977
Vividness977
Searchability866
Quality9.07.07.0
Response tokens1,5442981,169
Parse effortTrivialEasyModerate

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.

Merchant product-page artifact scores
Rubric axisMerchant PDP A · raw HTMLMerchant PDP B · rendered DOM
Sufficiency74
Vividness76
Searchability65
Response tokens544.4K823.9K
Parse effortSevereSevere

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?

search only spans covered catalogs; check catalog coverage for the stores your agent needs. A successful parse of 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 parse with resolutionMode: "on_demand_only" and onDemandCachePolicy: "refresh" to force a live read.

What happens on an index miss?

parse can 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.

Observed Apify fees in the 11-URL pilot
Apify profileObserved feePer 1k submitted URLsPer 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, build 0.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 parse for 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.