Scrape.do

Cancel a job that is still running. DESTRUCTIVE AND NOT REVERSIBLE: there is no un-cancel and no documented way to resume a canceled job -- the remedy is to create a new one. Tasks that had already succeeded keep their results until they expire; tasks that had not are abandoned. A job that has already finished cannot be canceled and answers `406 Not acceptable`, which is a state refusal rather than a bad request or a bad credential. Confirm the outcome by re-reading the job and looking for `canceled`, not by trusting this reply.

A paginated list of the account's asynchronous scraping jobs, newest first by default. Filter by `status` and by a start-time window, and page with `page`/`page_size`. Use this to find a `JobID` when you did not keep the one the create call returned. Timestamps are CASE-SENSITIVE RFC3339 with an uppercase `T` and `Z` (`2026-01-01T00:00:00Z`); an invalid value for any filter answers 400 rather than being ignored.

One job by its id, with every task it holds and each task's current state. The state vocabulary is `queuing` (being prepared), `queued` (waiting), `pending` (running), `rotating` (retrying through different proxies), `success`, `error` and `canceled` -- the last three are terminal. Poll this with exponential backoff rather than tightly, or configure a `WebhookURL` on the job and do not poll at all. A task's own payload comes from the task read, not from here.

One task inside a job: its state and, once it has reached `success`, the scraped result. This is where a finished async scrape is actually read. Check the task's `Status` before reading its payload -- a task in `error` carries the failure rather than a page -- and read it before its `ExpiresAt`, because Scrape.do stores task results only temporarily.

The authenticated account as the Async API sees it: subscription state, credit allowance and what is left of it, and the concurrency the async pool currently has free. Read `FreeConcurrency` before submitting a large batch, and the remaining-credit figures to decide whether a run is affordable. This is the right tool for "is this connection alive and what is left on it" -- note it is the ASYNC host's account view (`q.scrape.do`), not the synchronous API's `/info`, which this integration does not ship because it answers 200 with `IsActive:false` to a token it has rejected.

The complete HTML source of any Amazon URL, optionally ZIP- or country-targeted -- for pages the structured tools do not cover. RETURNS MARKUP, NOT PARSED FIELDS: prefer the product, search, offers, seller, best-sellers or deals tools whenever one of them covers what you need, because they return JSON and this returns a page you have to parse. When `zipcode` is set the request goes through the ZIP-keyed cookie pool that locks the delivery location; for marketplaces without ZIP-level delivery pass `countryName` instead. The reply is capped -- a page larger than the inline limit is refused rather than truncated, and the async job tool with a `WebhookURL` is the route for genuinely large pages. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

Amazon's ranked chart for a category -- Best Sellers, or New Releases with `type=new-releases`. READ BOTH ARRAYS: Amazon publishes a Top 100 as two pages of 50 and renders full product cards for only the first 30 positions on each, so `ranking` is the complete ordered chart for the page while `products` is the subset with price and rating. Join them on `asin`. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

Amazon's discounted-product grid as a paginated, filterable list. Every product carries its current price alongside the struck-through price it was reduced from, so compute the discount yourself rather than trusting a badge. Scope it to a category with `node`, bound it with `low_price`/`high_price`, narrow it with Amazon's own `rh` refinement string, and sort with `sort_by`. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

Every seller listing for one ASIN -- price, shipping cost, seller id and name, condition and Buy Box status -- the same data as Amazon's "All Offers" page, parsed. This is the price- comparison and competitive-intelligence read. Pair it with the seller-profile tool: this one says WHICH sellers carry an ASIN (`sellerId`), that one says who they are. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

One Amazon product detail page, parsed: title, price, rating and review count, images, the long-form description, best-seller rankings and the technical specification table. No HTML handling on your side. Price and availability follow the delivery location, so pass `zipcode` (or `countryName` where the marketplace has no ZIP-level delivery) rather than accepting whatever default Amazon picks. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

Keyword search or category browse on Amazon, parsed into product listings with title, price, rating, Prime status, sponsored flag and position. Amazon's category pages share the search page's structure, so this one tool serves both: pass `keyword` for a search, or `node`/`rh`/`i` copied from a category URL to browse. Page with `page`. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

The profile page for one Amazon seller id: display name, the seller's own blurb, the headline positive-feedback percentage and the business details Amazon publishes. On EU marketplaces that includes the trader-transparency block -- registered business name and type, trade register number, VAT number, phone, email and registered address -- and OUTSIDE THE EU most of those are simply absent, so treat every field as optional rather than reading an empty value as a scrape failure. Get seller ids from the offer-listing tool. COSTS 1 CREDIT per successful request -- the cheapest family here, because Scrape.do routes `amazon.*` through this scraper by default.

Send one prompt to `chatgpt.com` and get the assistant's reply back as structured JSON -- text with citation markers stripped, plus `output.markdown` and `output.html` for display, `sources[]`, `tool_data` and the model slug. Stateless: no account, no cookies, no conversation id to carry. `q` is capped at 1,024 characters. COSTS 25 CREDITS per successful request, the most expensive tool in this integration; failed requests are not charged and there is no additional render fee. For many prompts, submit them through the async job tool with the `chatgpt/chat` plugin key instead of calling this in a loop.

Send one prompt to `gemini.google.com` and get Gemini's reply back as structured JSON. One GET, no Google account, no cookies, no browser automation. COSTS 25 CREDITS per successful request; failed requests are not charged and there is no render fee. URL-encoding of a multi-word prompt is handled for you -- pass `q` as plain text.

Google's flight feed as JSON: per-segment `flights[]`, `layovers[]`, `total_duration`, `price`, `carbon_emissions`, airline logo and a `booking_token`, plus aggregate price insights and airport metadata. One call, no rendering and no booking-flow scraping. `departure_id`/`arrival_id` take IATA airport or city codes. A one-way search needs no `return_date`; a round trip does. COSTS 10 CREDITS per successful request.

The online-ordering providers on a restaurant's Google "Order online" page, with `pickup[]` and `delivery[]` returned together in Google's display order -- one call rather than one per fulfilment mode. `mid` is the Google Knowledge Graph machine id of the restaurant, which the Maps place and search tools return. COSTS 10 CREDITS per successful request.

STEP ONE OF TWO. Search Google Hotels and get property metadata -- name, photos, GPS, ratings, amenities and a per-night price -- plus a `detail_token` for each property. Feed that token to the hotel-detail tool for the per-vendor offer shelf. Filter by price band, rating, hotel class, amenities, property type, free cancellation, eco certification and special offers; page with the `next_page_token` a previous reply returned. Both dates are required, even for a price-only lookup. COSTS 10 CREDITS per successful request.

STEP TWO OF TWO. The full per-vendor offer shelf for ONE property -- Booking.com, Hotels.com, Agoda and the rest -- with live `rate_per_night` and `total_rate`. `detail_token` comes from a hotel-search reply and is the only way in; the dates must be sent again because the rates are stay-specific. COSTS 10 CREDITS per successful request.

The enriched record for ONE Google Maps place: menu, popular times, user reviews, images, plus code, opening hours and service options. Designed as a follow-up to a Maps search -- take a `place_id` or `data_cid` from that reply's `local_results[]` and read the full record here. The upstream contract marks both identifiers as required; supply the one you hold, and Scrape.do answers 400 naming what it needed if that is not enough. COSTS 10 CREDITS per successful request.

Paginated user reviews for one Google Maps place: rating, ISO dates, text with optional translation, images, reviewer profile, like count, guided-review detail and the owner's response where there is one. Sort with `sort_by` -- lowest-rated first is the complaint- monitoring view -- filter by `topic_id` or a free-text `query`, and page by replaying `pagination.next_page_token` until it stops coming back. COSTS 10 CREDITS PER PAGE, so bound the walk or run it as an async job rather than looping here.

A Google Maps search for any query, returning a paginated list of places with ratings, addresses, contact details and opening hours, all parsed. START HERE: the place and reviews tools both take identifiers this reply carries. Centre the search on a coordinate with `ll` and page with `start`, which is an OFFSET rather than a page number. COSTS 10 CREDITS per successful request.

Google News as JSON -- articles, topic clusters, menu navigation and related topics. SIX DRIVER PARAMETERS, and you use ONE of them per call: `q` to search by keyword, `topic_token` to browse a topic, `section_token` to drill into a section, `story_token` to expand a story cluster, `publication_token` to read one publication's page, or `kgmid` to pivot through a Knowledge Graph entity. Every token comes from a previous reply and they are not stable across responses -- use the freshest one rather than a cached one. The upstream contract marks all six as required; in practice you supply the driver you are using, and Scrape.do answers 400 naming what it needed if the combination is wrong. COSTS 10 CREDITS per successful request.

Find Play Store apps by query, category or top chart, with titles, ratings, prices and the package identifiers the app-detail and reviews tools take. Pass `q` to search, `apps_category` to browse, or `chart` to read a top chart. Page with the `next_page_token` a previous reply returned. COSTS 10 CREDITS per successful request.

The full Play Store details page for one app: description, version, download count, screenshots, release notes and developer information. `product_id` is the package name, for example `com.spotify.music`, which the Play Store search tool returns. COSTS 10 CREDITS per successful request.

Paginated user reviews for one Play Store app: rating, date, the app version reviewed and the developer's response where there is one. Page by replaying the `next_page_token` from a previous reply. COSTS 10 CREDITS per successful request, so a full review history for a popular app is many calls -- bound it, or submit the pages as one async job.

A Google search parsed into structured JSON: organic results, ads, knowledge graph, local pack, video results, related questions and the rest, with no HTML handling on your side. Page with `start`, which is an OFFSET rather than a page number. `resolveGoto` follows Google's redirect wrappers so links come back as their real destinations. Localize with `location` (free text, encoded for you) rather than `uule` unless you already hold an encoded value. COSTS 10 CREDITS per successful request -- Scrape.do applies a residential proxy to `google.*` by default, which is why this is ten rather than one.

Google AI Mode: a conversational search whose primary content is an AI-generated answer in structured text blocks with inline references and shopping results, rather than a list of links. Scrape.do fetches Google's AI Mode async payload directly, so no JavaScript rendering is involved, there is no render fee and latency is lower than a full-browser scrape. COSTS 10 CREDITS per successful request.

The follow-up call for an AI Overview a search returned as `state: "deferred"`. Replay the `session_key` from that reply and get the completed overview -- `text_blocks` with `reference_indexes`, plus `references` -- with `state` now `complete` or `unavailable`. SESSION KEYS EXPIRE AFTER 90 SECONDS AND ARE SINGLE-USE: once fetched they are deleted, and an expired or already-used key answers `404 {"error": "session not found"}`, which means re-run the search for a fresh one rather than retrying this call. It does not accept `resolveGoto`. COSTS 5 CREDITS, the cheapest Google call here.

Google Shopping search results -- organic listings plus sponsored product ads -- as structured JSON, roughly 40 products a page with title, price and original price, retailer, rating and review count, delivery information, discount badges and a Google product id. START HERE to get the `catalog_id` the shopping-product tool takes. Page with `start`, which is an OFFSET. COSTS 10 CREDITS per successful request.

The full Google Shopping product page for one item: the first batch of seller offers, variants, specifications, reviews, videos and related discussions. THE FLOW IS THREE STEPS -- search Google Shopping to get a `catalog_id`, call this for the page and its first sellers, then replay the `next_page_token` it returns against the shopping-product-stores tool to walk the rest of the seller list. A `catalog_id` is REGION-SCOPED: re-search per market rather than reusing one across locales. COSTS 10 CREDITS per successful request.

The continuation call that walks the rest of a Google Shopping product's seller list, roughly ten sellers at a time. Replay the `next_page_token` from the product page (or from the previous call of this tool) together with THE SAME `catalog_id`: the token is signed and bound to it, and a mismatch answers `400 catalog_id mismatch`. The locale is carried inside the token, so do not resend `q`, `gl` or `hl`. The reply is LEAN -- `product_id`, `stores[]` and the next token only; the title, gallery and variants are not re-emitted because you already have them. Keep going until no token comes back. COSTS 10 CREDITS PER CALL.

What is trending on Google right now for one country -- the same data as `trends.google.com/trending`. `geo` is required and decides the country. Widen or narrow the window with `hours`, filter to a category with `cat`, order with `sort` (relevance by default or by search volume) and choose whether to include topics that have stopped trending with `status`. COSTS 10 CREDITS per successful request.

Google Trends for a keyword: interest over time, interest by region, related queries and related topics. Narrow to one of those with `data_type`, set the window with `date` (Google's own notation, for example `today 12-m` or `today 5-y`), scope it geographically with `geo`, restrict the surface with `gprop` (web search, YouTube, news, images, shopping) and set the regional resolution with `region`. COSTS 10 CREDITS per successful request.

A parsed YouTube search-results page: videos, channels, playlists, Shorts shelves, ads and the discovery rails (`people_also_watched`, `from_related_searches`, `channels_new_to_you`, `explore_more`). Typically 15-20 videos a page; set `num` (1-30) and the plugin pages internally until it holds that many, still for ONE flat charge. `sp` is both the filter token (videos-only, channels-only, sort mode, duration, upload date, 4K/HD/LIVE/captions) and the continuation cursor -- replay the `pagination.next_page_token` from a previous reply to go deeper. COSTS 10 CREDITS per successful request, whether or not `num` paged internally.

A `homedepot.com` product page fetched through a store-scoped session, so the pricing, availability and fulfilment options are the ones that store offers. RETURNS HTML, NOT PARSED FIELDS -- typically around 700 KB -- so parse it yourself; and note Home Depot loads some pricing through client-side calls after the initial render, so a field missing from the markup is being fetched separately by the page rather than withheld by the API. `url`, `storeid` and `zipcode` are all effectively required: omitting any answers 400 before the page is fetched, and costs nothing. Resolve a store id with the Home Depot stores tool. THIS PLUGIN IS SYNCHRONOUS ONLY -- the async job tool rejects it with `unsupported plugin key`. The reply is capped; an oversized page is refused rather than truncated. COSTS 10 CREDITS per successful request.

Home Depot stores near a postal code or a coordinate pair, as JSON, including the `storeId` values the product tool expects. Pass EITHER `zipcode` OR both `lat` and `lng`: sending neither answers `400 zipcode (or lat+lng) is required`, and `lat` without `lng` is refused the same way. THIS PLUGIN IS SYNCHRONOUS ONLY -- the async job tool rejects it with `unsupported plugin key`. COSTS 10 CREDITS per successful request.

Fetch a `lowes.com` URL through a store-scoped session, so prices, stock and fulfilment come back as that store serves them. `url`, `zipcode` and `storeid` are all effectively required: omitting any of them answers 400 BEFORE the page is fetched, so the request costs nothing. ONLY CERTAIN URL SHAPES ARE ACCEPTED -- `/pd/<slug>/<itemId>` and `/search...` return HTML, `/pl/<category>/<id>/products` and `/wpd/<itemId>/productdetail/<storeId>/<auth>/<zipCode>` return JSON, and anything else answers `400 valid lowes url expected`. For the `/wpd/` and `/collections/` shapes the store and ZIP segments INSIDE the path must match the `storeid` and `zipcode` parameters exactly. The reply is capped -- an oversized page is refused rather than truncated. COSTS 10 CREDITS per successful request.

Full detail for one Walmart item AS SOLD AT ONE STORE: the price and stock at that location, plus the description and specification table only the product page carries. `store` and `zipcode` are both required and both shape the answer -- a product read without them is a different product read. COSTS 10 CREDITS per successful request; failed requests are never charged.

A keyword search against ONE Walmart store, returning structured listings with the prices and availability that store actually offers. Sponsored placements are included and FLAGGED rather than removed, so drop them yourself if you do not want them. COSTS 10 CREDITS per successful request; failed requests are never charged.

Fetch ANY Walmart URL through a session already warmed for a specific store and get the upstream response verbatim -- HTML for a page, JSON for one of Walmart's own endpoints. Use it for what the parsed tools do not cover, such as a category listing or the full product markup; for plain search or product detail the dedicated tools are lighter and return JSON. `transparentresponse` returns the target's own status and body on a timeout instead of a 502, which changes what a failure looks like. The reply is capped -- an oversized page is refused rather than truncated, and a genuinely large fetch belongs in an async job with a `WebhookURL`. COSTS 10 CREDITS per successful request.

Queue a batch of scrapes and get a `JobID` plus one `TaskID` per target back immediately, instead of holding a request open while each page loads. The body carries EITHER `Targets` (a list of URLs to fetch raw) OR `Plugin` ({`Key`, `Params`}) to run one of the structured scrapers -- `amazon/pdp`, `google/search`, `google/maps/reviews` and twenty-odd others -- over up to 1,000 parameter sets in one job. THE TWO ARE MUTUALLY EXCLUSIVE: sending both answers 400. Optional `GeoCode` and `Super` apply to every task; `WebhookURL` (with optional `WebhookHeaders`) has results POSTed to you as they finish, which is the documented production pattern and avoids polling altogether. The async pool is SEPARATE from the synchronous concurrency limit -- an extra 30% of your plan's limit, not deducted from it -- so a full main pipeline does not block it. Results are stored temporarily: read each task before its `ExpiresAt`. Credits are spent per task as it succeeds, at whatever the target's own rate is, not by this call.