On-demand endpoints
Request-time extraction for application paths.
- POST extract with identifiers and fields
- Freshness parameter per request
- Synchronous and async job modes
- Bulk request batching
- Idempotent request IDs
The same managed pipelines, exposed as endpoints your systems call.
This is a delivery model, not a different service. The collection, QA and maintenance underneath are identical to our file-delivered engagements. What changes is that your application asks us for data instead of reading it from a bucket.
Free pilot on your own sources, returned in 24 hours. No card, no trial clock — and you keep the sample data either way.
Last verified 5 August 2026 by the Actowiz Solutions Data Engineering team.
A web scraping API exposes managed extraction as endpoints. Your application sends a request naming a source, identifiers and fields; the API returns structured records with metadata about freshness and any per-identifier failures.
It is worth being clear that this is the same service as our file-delivered engagements, differently packaged. The collection design, schema validation, human QA and source maintenance are identical. What differs is who initiates and when.
Most clients end up using both: API for the application path, scheduled files into the warehouse for analytics. We will tell you which fits which part of your requirement rather than pushing everything through one channel.
The hardest question in an extraction API is whether to serve cached data or fetch live. Cached is fast and cheap; live is current and slow. We make it your decision per request: freshness_max_minutes sets the maximum acceptable age, and the response reports served_from and age_minutes so you always know what you received.
The endpoints are the visible part. Versioning discipline and error semantics are what make it usable in production.
Request-time extraction for application paths.
Recurring collection you configure through the API.
Event-driven delivery.
The discipline that keeps you from breaking.
Because silent gaps are worse than errors.
Production concerns.
A managed engagement, not a tool licence. We own the pipeline and everything that breaks in it.
Every response carries the metadata needed to know what you got and how fresh it was.
| Field | Type | What it captures | Refresh |
|---|---|---|---|
request_id |
string | Idempotent request identity, so retries do not double-charge or double-fetch | Every response |
schema_version |
string | Exact schema version served, so client-side parsing is never ambiguous | Every response |
served_from |
enum | cache or live, so you know whether the response cost a fetch | Every response |
observed_at / age_minutes |
timestamp / int | When the underlying data was captured and how old it is now | Every response |
records |
array | Successful records in the agreed schema for the requested fields | Every response |
partial |
boolean | Whether some requested identifiers failed, set true rather than returning a short list silently | Every response |
errors |
array | Per-identifier error objects with codes and retry guidance | When partial |
rate |
object | Limit, remaining and reset seconds, mirrored in response headers | Every response |
job_id / job_status |
string / enum | For async and scheduled modes, job identity and current state | Job endpoints |
next_cursor |
string | Pagination cursor for large result sets | When paginated |
deprecation |
object | Present when the endpoint version is scheduled for retirement, with the date | When applicable |
A response with partial set true and a populated errors array is a successful response. An API that returns a short list without telling you which identifiers failed is the most common cause of silent data gaps in production.
Any source we collect can be exposed through the API. Endpoint design follows your source and field scope.
The API is a delivery model rather than a fixed catalogue. If we collect it in a managed engagement, it can be exposed as an endpoint. Request a source we don't list →
We deliver into 40+ countries. These are the markets where this particular service is requested most, and the reason demand concentrates there.
| Market | Why demand concentrates here |
|---|---|
| United States | The deepest market for product companies building live data into user-facing features, where request-time freshness matters commercially. |
| United Kingdom & European Union | Strong SaaS and comparison-platform sector where one consistent API envelope across many sources removes real integration cost. |
| India & Singapore | High volume of product engineering teams integrating external data, often replacing several self-built extraction paths with one contract. |
| United Arab Emirates & Saudi Arabia | Rapid platform building with limited existing data infrastructure, so API delivery is often the first data contract a team signs. |
We run production collection across 40+ countries. Coverage depth varies by market and by source, so we confirm what is actually available for your specific markets during scoping rather than claiming uniform global coverage. Ask about a market we don't list →
Product and platform engineering dominate, since the API exists to be integrated rather than analysed.
Your product needs current data at request time, and a nightly file cannot serve a user query.
Authenticated on-demand endpoints with a freshness parameter, versioned schemas and sandbox access before contracting.
Feature delivery speed
Every data source you add brings its own contract, error semantics and breaking changes.
One consistent envelope across all sources, with per-identifier errors and deprecation notice before breaking changes.
Integration maintenance load
Coverage and freshness are the product, and both need to be controllable per request.
Freshness as a request parameter with served_from and age reported, so product decisions about cost versus currency are yours.
Coverage and freshness SLA
You want an internal data service rather than teams each building their own extraction.
A single API your internal teams consume, with usage reporting per key so consumption is attributable.
Duplicate effort removed
Alerting needs push on change rather than polling for it.
Signed webhooks on change with retry, dead letter handling and replay, filtered per event type.
Alert latency
You need to know what happens when the vendor changes something, before you build on it.
Versioned endpoints, additive-only changes within a version, deprecation notice with dates, and a machine-readable schema endpoint.
Unplanned rework
Four patterns, with the outcome each is judged on.
The application calls the extract endpoint with identifiers and a freshness ceiling; the API serves from cache within that window or fetches live, and reports which it did.
Outcome: Users see current data without the product paying for a live fetch on every request.
Change-triggered webhooks push signed payloads on price, availability or content change, with retry and replay so no event is lost silently.
Outcome: Alerting latency measured in minutes without a polling loop against the API.
The API becomes the single internal route to external data, with per-key usage reporting so consumption is attributable to teams.
Outcome: Duplicate extraction efforts across teams consolidated onto one contract.
The application path uses on-demand endpoints while full-population data lands in the warehouse as scheduled Parquet, both from the same pipelines and schema.
Outcome: Each path served by the delivery model that suits it, on consistent data.
Clients rarely permit naming. These are real engagement shapes with identifying detail removed, so you can judge whether the work resembles your situation.
An existing provider returned successful responses with fewer records than requested and no indication which identifiers had failed, so gaps went unnoticed for months.
Migration to an envelope with an explicit partial flag, per-identifier error codes and retry guidance, tested in sandbox against the client's own code first.
Gaps became visible at request time and retryable, rather than discovered later without explanation.
The product had no way to express acceptable data age, so all requests fetched live, making latency and cost worse than the use case required.
Per-request freshness control with served_from and age reported, letting each feature choose cached or live independently.
Latency and fetch volume both fell, with currency preserved where the feature actually needed it.
Examples are anonymised at client request. Named references are available on request under NDA. See published case studies →
Before you commit to anything, we run this service against your own sources and send you the output. If the coverage isn't there, the sample will show you that too — which is the point. We would rather lose the deal at the pilot than at month three.
Same collection pipeline and same QA underneath. The difference is who holds the schedule and how the data reaches you.
We own the collection, the QA and the delivery. You receive clean data on a schedule and never touch a scraper.
Best fit: Teams who need the data, not the infrastructure.
The same collection pipeline exposed as an authenticated REST endpoint your systems query directly.
Best fit: Product and engineering teams building on live data.
A defined pull for a specific question — market sizing, diligence, a pitch, a one-off audit.
Best fit: Research, strategy and diligence work with a deadline.
Every engagement is quoted individually, because the honest answer depends on your scope: how many sources, how many records, how often, and how the data reaches you. We scope it with you, run a free pilot on your own sources, and then quote a fixed monthly figure — no per-request metering and no overage billing when volumes move. Request a quote and you will have a number after one call.
The API question is less about capability and more about who owns error semantics and breaking changes.
| Consideration | In-house scraping team | Generic proxy / DIY tool | Actowiz managed feed |
|---|---|---|---|
| Time to first usable data | 6–12 weeks of engineering before anything is trustworthy | Days, but output needs manual cleanup before use | Free pilot in 24 hours, production in 5–10 business days |
| Who fixes it when a source changes | Your engineers, at the cost of their roadmap | You do — tools report failures, they don't resolve them | We do, same business day, inside the retainer |
| Data quality assurance | Whatever your team has time to build | None beyond HTTP success | Schema validation plus sampled human QA on every run |
| Compliance documentation | Rarely produced, then requested urgently by legal | Not provided; terms risk sits with you | Sources, method and lawful basis documented for review |
| Accountability | Distributed across a team with other priorities | A support ticket queue | A named engineer and an account owner |
| True annual cost | Engineer salaries, proxies, hosting, ongoing maintenance | Low licence fee plus significant hidden analyst time | One fixed monthly retainer, quoted after scoping |
The most consequential design decision in an extraction API is what happens when some of a request fails. It is also the decision most often made badly, and the consequences are invisible until they are expensive.
You request 500 identifiers. The API returns 470 records with HTTP 200. No error, no flag. Your pipeline processes 470 records successfully and moves on. Thirty products silently have no data, and nothing anywhere records that.
Repeated daily, this produces gaps that correlate with exactly the things you care about — the products whose pages are hardest to fetch are often the ones changing most.
partial is explicit. Set true whenever any requested identifier did not return a record.source_unavailable, blocked, not_found and field_unavailable mean different things and need different client responses.retry_after_s per error. So a client knows whether to retry in two minutes or give up.This makes integration slightly more work upfront, because your client has to handle the errors array. That is the point. The alternative moves the work to whoever eventually notices the gap, months later, without the information needed to explain it.
Building on a vendor API means accepting that the vendor can break you. The only real mitigation is a versioning commitment you can read before you start.
/v3/extract keeps its contract. A breaking change means /v4, not a modified /v3.deprecation object with the date, and you are told directly.That nothing will ever change. Source sites change, and occasionally a field genuinely stops being available because a retailer stopped publishing it. When that happens we tell you, mark the field unavailable with a reason rather than returning nulls, and discuss alternatives — but we cannot conjure data a source no longer publishes, and any vendor implying otherwise is setting up a future surprise.
A sandbox key with representative data is available before contracting, specifically so you can test these semantics against your own client code rather than trusting a description of them.
Sources, fields, expected load profile and freshness requirements are scoped first, then a sandbox key is issued before contracting.
You send us target sites, regions, SKUs or keywords. We return a field-level schema proposal, coverage estimate and refresh recommendation — usually within two working days.
We extract a real sample from your actual targets so you can inspect field fill rates, edge cases and match quality before any commitment.
Our engineers build extractors, then wire validation rules: type checks, range checks, duplicate detection and golden-record comparison against a manually verified subset.
Feeds run at your chosen cadence and land in the warehouse or bucket you already use. Schema changes are versioned and announced before they ship.
We watch coverage drift, fill rates and source changes daily. A named engineer owns your account, and layout breaks are fixed by us — not queued for you.
Authenticated REST over HTTPS with JSON payloads. Webhook push with signed payloads. Bulk results via cursor pagination or signed download URLs. Files in JSON, JSONL, CSV or Parquet remain available in parallel for warehouse paths.
The API exposes the same publicly-sourced collection as our file-delivered engagements, under the same boundaries: publicly accessible pages only, no credentialed access, no personal data resale. API keys are client-specific with rotation supported, and usage is reported per key.
These are contractual, not marketing copy. They appear in the engagement document.
| Commitment | What we hold ourselves to |
|---|---|
| Pilot turnaround | A real sample from your own sources within 24 hours of scoping, at no cost. |
| Go-live | Production collection running within 5–10 business days of sign-off. |
| Delivery punctuality | 99.5% on-schedule delivery, measured monthly and reported to you. |
| Breakage response | Source layout changes triaged same business day; critical sources inside 4 hours. |
| Data quality | Schema validation on every run plus sampled human QA before any delivery leaves us. |
| Escalation | A named engineer and an account owner, not a shared ticket queue. |
| Change requests | Field additions and source changes handled inside the retainer, not re-quoted. |
| Exit | Your historical data exported in full on request. No lock-in, no export fee. |
Plain definitions of the terms used on this page, so procurement and legal reviewers are working from the same vocabulary as your data team.
What engineering and platform teams ask during evaluation.
The same service, differently delivered. Collection design, schema validation, human QA and source maintenance are identical to our file-delivered engagements. What changes is that your application initiates the request.
Most clients use both: API for the application path where request-time data matters, and scheduled files into the warehouse for analytics and full-population work, where pulling everything through an API would be slower and more expensive.
Yes, per request. freshness_max_minutes sets the maximum age you will accept; we serve from cache within that window or fetch live if not. The response reports served_from and age_minutes so you always know what you received.
This is deliberately your decision rather than ours. Cached is fast and cheap, live is current and slow, and the right tradeoff differs by feature within the same product.
You get a successful response with partial set true and an errors array naming each failed identifier, an error code and retry_after_s guidance. Codes distinguish source_unavailable, blocked, not_found and field_unavailable.
We never return a short list silently. An API that returns 470 records for a 500-identifier request with no flag is the most common cause of silent production data gaps, and those gaps correlate with the products you care about most.
Versioned endpoints. /v3/extract keeps its contract; a breaking change becomes /v4. Within a version, changes are additive only — new optional fields may appear, existing fields do not change type, meaning or nullability.
Deprecation carries a dated deprecation object in responses plus direct notice, with an overlap period long enough to migrate calmly. There is a machine-readable schema endpoint per version and a changelog.
Agreed to your load profile during scoping rather than assigned as a fixed tier. We would rather size limits to your actual peak than have you discover a ceiling in production.
Every response carries rate with limit, remaining and reset seconds, mirrored in headers. If your load grows, limits are revised inside the retainer rather than triggering a plan upgrade.
Yes. A sandbox key with representative data is issued before contracting, specifically so you can test error semantics, response shapes and your own client code against the real contract rather than a description of it.
We would rather you find an integration problem in sandbox than after signature. The sandbox is part of the free pilot.
Yes, for change-triggered push. Payloads are signed with replay protection, retries use exponential backoff, and undeliverable events go to a dead letter store you can replay from.
Webhooks suit alerting and event-driven architectures better than polling. If your use case is analytics rather than reaction, scheduled files are usually the better fit and we will say so.
We tell you, and the field is marked unavailable with a reason code rather than returning nulls that look like data. Sources do occasionally stop publishing things.
What we will not do is claim nothing will ever change, or quietly substitute an estimate. If a retailer stops publishing a field, no vendor can supply it, and pretending otherwise creates a worse surprise later.
We quote individually. Drivers are source count, field scope, expected request volume and how much of it needs live rather than cached fetching — live fetching is the main cost variable.
Pricing is a fixed monthly retainer sized to your load profile, not per-request metering. That means a traffic spike does not produce a surprise invoice, and it means we scope your peak honestly upfront. One scoping call, a sandbox key within 24 hours, then a fixed monthly quote. Request a quote.
Tell us the sources and fields you need. We issue a sandbox key with representative data within 24 hours so you can test response shapes and error semantics against your own code.
Free sandbox, no card, no obligation. Find integration problems before signature, not after.Our web scraping expertise is relied on by 4,000+ global enterprises including Zomato, Tata Consumer, Subway, and Expedia — helping them turn web data into growth.
Watch how businesses like yours are using Actowiz data to drive growth.
From Zomato to Expedia — see why global leaders trust us with their data.
Backed by automation, data volume, and enterprise-grade scale — we help businesses from startups to Fortune 500s extract competitive insights across the USA, UK, UAE, and beyond.
We partner with agencies, system integrators, and technology platforms to deliver end-to-end solutions across the retail and digital shelf ecosystem.
Wegmans Grocery Product Data Extraction helps retailers track prices, products, availability, and assortment changes to improve grocery market intelligence and decisions.
Track Scrape Ready-to-Cook Cut Veg Product Data from Blinkit TN to monitor prices, availability, SKUs, and trends for smarter retail insights.
Brazil Car Rental Pricing Intelligence Report 2026 reveals rental price trends, market shifts, competitor rates, and opportunities for smarter pricing.
Whether you're a startup or a Fortune 500 — we have the right plan for your data needs.