# Web Scraper API - Any URL, Anti-Bot Proxy, JS Render & AI (`fayoussef/web-scraper-api-any-url-anti-bot-proxy-js-render-ai`) Actor

Free web scraper API for any website. Rotating anti-bot proxies, JS rendering, screenshots, CSS + AI extraction. Clean HTML, Markdown and JSON.

- **URL**: https://apify.com/fayoussef/web-scraper-api-any-url-anti-bot-proxy-js-render-ai.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Developer tools, Automation, AI
- **Stats:** 1 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Web Scraper API - Scrape Any URL With Anti-Bot Proxies, JS Rendering & AI

**Web Scraper API is a free, universal web scraping tool that turns any URL into clean HTML, LLM-ready Markdown, and structured JSON.** It routes every request through rotating anti-bot proxies in **220+ countries**, renders JavaScript in a real headless browser, runs browser actions (click, scroll, type), captures screenshots, and can run an AI model over each page - so you get reliable data from even the most protected sites without managing browsers, proxies, or CAPTCHAs.

Point it at **Amazon, eBay, Walmart, Google, Google Maps, LinkedIn, Instagram, TikTok, Zillow, Yelp, Booking.com, Indeed, Crunchbase, Idealista** - or your own list of URLs. Add CSS selectors or an LLM prompt and get structured output in one run. Or skip HTML entirely and use a built-in **Ready-made scraper** for Amazon, Google, YouTube, and ChatGPT that returns clean JSON. Built for developers, researchers, e‑commerce sellers, growth teams, and AI agents.

> **✅ Free to use - no rental, no per-result fee from this Actor.** You only pay your own scrape.do usage for the underlying requests, and you can **[grab a free scrape.do token with 1,000 monthly credits →](https://scrape.do/?fpr=automationbyexperts)** (no credit card required).

> **Try it now:** the default input already points at live Amazon and eBay search results. Paste your Scraper API token, hit **Start**, and you'll get structured product data back in seconds.

### Why use this web scraper API

- **🆓 Free Actor:** no monthly rental and no pay-per-result charge - bring your own scrape.do key and start with 1,000 free monthly credits.
- **🛡️ Beat anti-bot systems:** rotating datacenter + residential/mobile proxies across 220+ countries handle Cloudflare, DataDome, PerimeterX and rate limits for you.
- **🌐 Any site, famous or niche:** Amazon, Google, LinkedIn, Instagram, TikTok, Zillow, Booking.com, Yelp, Indeed - or any URL you paste.
- **🎭 Full headless browser:** render JavaScript, wait for selectors, scroll infinite feeds, click "load more", fill forms, and run custom JS via browser actions.
- **📸 Screenshots:** capture viewport or full-page screenshots, saved straight to your dataset's key-value store.
- **🤖 LLM-ready output + built-in AI:** every page becomes Markdown with embedded JSON‑LD/script data - perfect for RAG - and an optional AI step can summarize, classify, or extract JSON.
- **⚡ Auto-scaled & resumable:** concurrency is sized to your live plan limit, and runs are migration-safe (they resume without re-scraping or duplicating data).

### Supported scraping features (all of scrape.do)

| Feature | Input | What it does |
|---|---|---|
| JavaScript rendering | `render` | Real headless browser executes JS before returning HTML |
| Geo-targeting (country) | `geoCode` | Route through a proxy in a specific country |
| Geo-targeting (continent) | `regionalGeoCode` | Route through a whole continent |
| Residential / mobile proxy | `superProxy` | Premium pool for the hardest targets |
| Device profile | `device` | Imitate desktop, mobile, or tablet |
| Sticky sessions | `sessionId` | Reuse the same exit IP across a multi-page flow |
| Cookies | `setCookies` | Send `name=value` cookies to the target |
| Custom / forwarded headers | `customHeaders`, `forwardHeaders` | Control the exact headers the site sees |
| Disable redirects | `disableRedirection` | Return the first response without following 3xx |
| Wait strategy | `waitUntil`, `customWait`, `waitSelector` | Wait for load events, a fixed delay, or a specific element |
| Viewport | `viewportWidth`, `viewportHeight` | Set the render window size |
| Block resources | `blockResources` | Skip images/CSS/fonts for faster, cheaper rendering |
| Browser actions | `playWithBrowser` | Click, scroll, type, wait, execute JS in sequence |
| Screenshots | `screenShot`, `fullScreenShot` | Capture viewport or full-page image |
| Scraper timeout | `scrapeTimeout` | Max time the API spends fetching/rendering a page |
| CSS extraction | `extractRules` | Pull fields with `{ "name": "css selector" }` |
| AI processing | `llmEnabled` + `llmPrompt` | Summarize / classify / extract JSON per page via OpenRouter |
| **Ready-made scrapers** | `scraperApi` | Structured JSON for Amazon, Google, YouTube & ChatGPT - no parsing |

Geo-targeting covers **220+ countries** (pick any in the dropdown) plus whole-continent routing.

### Ready-made structured scrapers (JSON, no parsing)

Set **`scraperApi`** to one of scrape.do's dedicated endpoints and the Actor returns clean, already-parsed JSON in a `data` field - no CSS selectors, no HTML. Put your inputs in **`scraperApiQueries`** (one per line):

| Mode (`scraperApi`) | Input per line | Returns |
|---|---|---|
| `amazon-product` | product URL or ASIN | Full product detail - title, price, rating, images, specs |
| `amazon-search` | search keyword | Ranked search results |
| `amazon-offers` | product URL or ASIN | Every seller offer, price & shipping |
| `google-search` | search query | SERP results + AI overviews |
| `google-maps` | place / business query | Places, ratings & reviews |
| `google-shopping` | product query | Shopping listings with prices |
| `google-news` | news query | News articles |
| `youtube` | search query | Videos, channels, playlists, shorts |
| `chatgpt` | prompt | ChatGPT's answer as structured JSON |

Shared options: `readyApiLanguage` (language / `hl`), `geoCode` (country / `gl`), and `amazonZipcode` (Amazon location pricing). Example - scrape three Amazon products as JSON:

```json
{
  "apiKey": "YOUR_API_TOKEN",
  "scraperApi": "amazon-product",
  "scraperApiQueries": [
    "https://www.amazon.com/dp/B0CHWRXH8B",
    "B09G9FPHY6",
    "https://www.amazon.com/dp/B0BDHWDR12"
  ],
  "geoCode": "us",
  "amazonZipcode": "90210"
}
````

> Ready APIs run one request at a time per token and cost more credits per call (Google/YouTube ≈ 10, ChatGPT ≈ 25). You can still turn on the LLM step to post-process the JSON.

### What you get

Every URL produces one dataset record with these fields:

- `url` - the page that was scraped.
- `statusCode` - HTTP status returned by the target.
- `ok` - `true` when the status was 2xx.
- `error` - error message for failed URLs (null on success).
- `scrapedAt` - ISO 8601 UTC timestamp of the scrape.
- `html` - full raw HTML (toggle off with `storeHtml`).
- `text` - the page as **LLM-ready Markdown**: headings, links, lists, and tables preserved, with structured JSON from `<script>` tags appended. Built to drop straight into an LLM prompt.
- `textLength` - character count of `text`.
- `structuredData` - JSON pulled from `<script>` tags (JSON-LD, `__NEXT_DATA__`, etc.) as `{source, data}` - where Amazon/eBay/SSR sites keep their cleanest product data. Present only when found.
- `extractedFields` - your CSS-selector fields as a key/value object.
- `llmOutput` - optional AI result (text or parsed JSON), as a top-level field next to `html`/`text`. Accompanied by `llmModel`, `llmUsage`, and `llmError`.
- `screenshotUrl` / `screenshotKey` - link to the captured screenshot in the key-value store (when screenshots are on).
- `options` - echo of `render`, `geoCode`, `regionalGeoCode`, `superProxy`, `device`, and `screenshot` used per request.

### Sample output

````json
{
  "url": "https://www.amazon.com/dp/B0CHWRXH8B",
  "statusCode": 200,
  "ok": true,
  "html": "<!DOCTYPE html><html>...</html>",
  "text": "# Wireless Earbuds Bluetooth 5.4 Headphones\n\n40H Playtime · 4.5 out of 5 stars · **$29.99**\n\n## Structured data (from page scripts)\n\n### application/ld+json\n```json\n{ \"@type\": \"Product\", \"name\": \"Wireless Earbuds\", \"offers\": { \"price\": \"29.99\" } }\n```",
  "textLength": 18742,
  "structuredData": [
    { "source": "application/ld+json", "data": { "@type": "Product", "name": "Wireless Earbuds", "offers": { "price": "29.99", "priceCurrency": "USD" } } }
  ],
  "extractedFields": {
    "title": "Wireless Earbuds Bluetooth 5.4 Headphones",
    "price": "$29.99"
  },
  "llmOutput": { "title": "Wireless Earbuds Bluetooth 5.4", "price": 29.99, "rating": 4.5, "inStock": true },
  "llmModel": "google/gemini-3.1-flash-lite",
  "llmUsage": { "prompt_tokens": 4120, "completion_tokens": 48, "total_tokens": 4168 },
  "llmError": null,
  "options": { "render": true, "geoCode": "us", "regionalGeoCode": null, "superProxy": false, "device": "desktop", "screenshot": false },
  "scrapedAt": "2026-06-25T12:00:00.000000+00:00",
  "error": null
}
````

### What you can build with it

Real things people use this Actor for - copy any of these as a starting point:

- **🛒 Amazon, eBay & Walmart price tracking** - feed product or search URLs and pull `title` + `price` on a schedule to watch competitors, catch price drops, or track your own listings. Add `geoCode` to compare prices across countries (US vs. UK vs. DE).
- **📦 E-commerce catalog & inventory monitoring** - scrape any store to track stock status, new arrivals, ratings, and reviews into a spreadsheet or database.
- **🗺️ Local business & reviews data** - pull listings, ratings, and reviews from Google Maps, Yelp, or TripAdvisor.
- **🏠 Real-estate & rentals** - collect listings and prices from Zillow, Booking.com, or Idealista, and screenshot each listing.
- **💼 Lead generation & recruiting** - pull names, companies, and roles from LinkedIn-style directories, Crunchbase, or Indeed job pages (use `superProxy` + `sessionId`).
- **🤖 Feed AI agents & RAG pipelines** - give Claude, ChatGPT, or Cursor live web data over MCP; the LLM-ready Markdown `text` drops straight into embeddings and prompts.
- **🔍 SERP & SEO monitoring** - scrape Google or Bing results behind anti-bot protection to track rankings and visibility.
- **📰 News, reviews & sentiment** - collect article text or reviews and let the built-in LLM summarize, classify, or score sentiment in the same run.
- **📸 Visual monitoring & QA** - capture full-page screenshots of competitor pages, ads, or your own site over time.

#### Quick recipes

| Goal | `startUrls` example | Key options |
|---|---|---|
| Amazon product price | `https://www.amazon.com/dp/B0CHWRXH8B` | `extractRules: { "title": "#productTitle", "price": ".a-price .a-offscreen" }` |
| Amazon search results | `https://www.amazon.com/s?k=wireless+earbuds` | `render: true` |
| eBay listing | `https://www.ebay.com/itm/123456789012` | `extractRules: { "title": "h1.x-item-title__mainTitle", "price": ".x-price-primary" }` |
| Google search results | `https://www.google.com/search?q=best+headphones` | `render: true`, `geoCode: "us"` |
| Google Maps place | `https://www.google.com/maps/place/...` | `render: true`, `waitSelector: "h1"` |
| Infinite-scroll feed | any social/listing feed | `playWithBrowser: [ {"Action":"ScrollY","Value":3000}, {"Action":"Wait","Timeout":2000} ]` |
| Full-page screenshot | any URL | `fullScreenShot: true` |
| Hard target (LinkedIn/Zillow) | any protected URL | `superProxy: true`, `sessionId: "s1"`, `render: true` |

> Don't want to write selectors? Turn on **🤖 LLM processing**, set `Force JSON output`, and prompt: *"Extract product title, price as a number, rating, and whether it's in stock."*

### Browser actions (`playWithBrowser`)

Automate the headless browser before the page is captured. Provide a list of steps that run in order:

```json
[
  { "Action": "ScrollY", "Value": 1000 },
  { "Action": "Wait", "Timeout": 2000 },
  { "Action": "Click", "Selector": "#load-more" },
  { "Action": "WaitSelector", "WaitSelector": ".results", "Timeout": 5000 },
  { "Action": "Fill", "Selector": "#search", "Value": "laptop" },
  { "Action": "Execute", "Execute": "window.scrollTo(0, document.body.scrollHeight)" }
]
```

Supported actions: **Click** (`Selector`), **Wait** (`Timeout` ms), **WaitSelector** (`WaitSelector`, `Timeout`), **ScrollX / ScrollY** (`Value`), **ScrollTo** (`Selector`), **Fill** (`Selector`, `Value`), **Execute** (`Execute` JS). Enabling browser actions turns JavaScript rendering on automatically.

### Pricing

**This Actor is free.** There is no monthly rental and no per-result charge from the Actor itself - you only pay Apify's standard platform usage (compute) while it runs, plus your own scrape.do credits for the underlying requests. **[Get 1,000 free monthly scraping credits here](https://scrape.do/?fpr=automationbyexperts)** to cover those requests at no cost.

### How it works

- **Input:** a list of `startUrls` plus your Scraper API token.
- **Fetch:** each URL is routed through rotating anti-bot proxies, with optional JavaScript rendering, geo-targeting, device profile, sticky sessions, and browser actions.
- **Process:** apply CSS `extractRules`, capture a screenshot, and/or run an LLM prompt on each page.
- **Output:** structured records land in the Apify dataset (export as JSON, CSV, Excel, or XML); screenshots go to the key-value store.
- **Automate:** run on a schedule and trigger webhooks on finish - built into the Apify platform.

### Input example

```json
{
  "apiKey": "YOUR_API_TOKEN",
  "startUrls": [
    { "url": "https://www.amazon.com/s?k=wireless+earbuds" },
    { "url": "https://www.ebay.com/sch/i.html?_nkw=wireless+earbuds" }
  ],
  "render": true,
  "geoCode": "us",
  "device": "desktop",
  "extractRules": { "title": "h1", "price": ".a-price .a-offscreen" }
}
```

Omit `extractRules` and `llm*` fields to just return clean HTML and text. Set `concurrencyPercentage` to control speed.

### FAQ

**Is this web scraper API really free?**
Yes. The Actor has no rental and no per-result fee. You pay only Apify's standard compute usage while it runs and your own scrape.do credits for the requests - and scrape.do gives you 1,000 free credits a month.

**Which websites can it scrape?**
Any public URL, including heavily protected sites like Amazon, eBay, Walmart, Google, Google Maps, LinkedIn, Instagram, TikTok, Zillow, Yelp, Booking.com, Indeed, and Crunchbase.

**Does it handle anti-bot protection and proxies?**
Yes. Every request is routed through a rotating proxy network, with optional residential/mobile proxies (`superProxy`) and per-country or per-continent geo-targeting.

**Can it render JavaScript / dynamic sites?**
Yes - set `render: true` for SPAs and dynamic pages. You can also wait for elements (`waitSelector`), add delays (`customWait`), and run browser actions (scroll, click, type).

**Can it take screenshots?**
Yes. Enable `screenShot` (viewport) or `fullScreenShot` (full page); the image is saved to the key-value store and linked from each record via `screenshotUrl`.

**What output formats are supported?**
The dataset exports to JSON, CSV, Excel, and XML, or via the Apify API. Screenshots are PNG/JPEG in the key-value store.

**Can I scrape one URL or many?**
Both. Pass a single URL or thousands in `startUrls`; they are scraped concurrently.

**Does it support scheduling and webhooks?**
Yes - use Apify schedules to run it automatically and webhooks to push results downstream.

**Is the data live or cached?**
Live. Each run fetches the current page in real time.

**How do I extract specific fields?**
Provide `extractRules` as a `{ "fieldName": "css selector" }` map, or set an `llmPrompt` for AI extraction.

**Can AI agents call it?**
Yes - it's available via the Apify REST API and as an MCP server for Claude, ChatGPT, and Cursor (see below).

**Is web scraping legal?**
Scraping publicly available data is generally legal in most jurisdictions, and this Actor only fetches public pages you point it at. You are responsible for respecting each target site's terms of service, robots rules, rate limits, and any applicable data-protection laws (for example GDPR when personal data is involved). Do not use it to collect private data or bypass authentication.

### Use via API or MCP

Run it programmatically via the Apify REST API:

```
POST https://api.apify.com/v2/acts/fayoussef~universal-scraper-api/runs?token=YOUR_TOKEN
```

Or connect it as an MCP server so AI agents can call it directly:

```
https://mcp.apify.com/actors/fayoussef~universal-scraper-api
```

### Need a custom scraper?

Need different fields, a specific site, or a fully managed pipeline? Visit [automationbyexperts](https://automationbyexperts.com).

# Actor input Schema

## `apiKey` (type: `string`):

Your personal Scraper API token — the underlying scraping requests are billed to your own scrape.do account (this Actor itself is free). 👉 Don't have one? **[Create a free account and get 1,000 free monthly credits](https://scrape.do/?fpr=automationbyexperts)** — no credit card required. Paste your token from the dashboard once you sign up.

## `startUrls` (type: `array`):

List of URLs to scrape. Each URL is fetched through the Scraper API and pushed to the dataset as a structured record. Works on famous, heavily-protected sites — **Amazon, eBay, Walmart, Google, Google Maps, LinkedIn, Instagram, TikTok, Zillow, Yelp, Booking.com, Indeed, Crunchbase, Idealista** and thousands more. The defaults below are live Amazon and eBay search pages — swap in any product, search, profile, category, or listing URL you need. Tip: keep **Render JavaScript** ON for JS-heavy / protected sites.

## `scraperApi` (type: `string`):

Optionally switch to one of scrape.do's **Ready APIs** — dedicated endpoints that return clean, already-parsed JSON for a specific target instead of raw HTML. When set, the Actor scrapes the entries in **Ready API inputs** below (not Start URLs). Leave on "Off" for normal URL scraping. Note: Ready APIs run one-at-a-time per token and cost more credits per call (Google/YouTube ≈ 10, ChatGPT ≈ 25).

## `scraperApiQueries` (type: `array`):

The inputs to run through the selected **Ready-made structured scraper** — one per line. What each line should contain depends on the mode: a product URL/ASIN (Amazon product/offers), a keyword or query (Amazon/Google/YouTube search), or a prompt (ChatGPT). Ignored when the mode is "Off".

## `readyApiLanguage` (type: `string`):

Interface / results language for the Ready API (ISO 639-1, e.g. `en`, `es`, `de`). Maps to `language` for Amazon and `hl` for Google/YouTube. Leave empty for the provider default. Ignored by ChatGPT.

## `amazonZipcode` (type: `string`):

Amazon-only: a ZIP / postal code to get location-specific pricing, availability and delivery (Amazon Ready API `zipcode`, e.g. `90210`). Ignored by other modes.

## `render` (type: `boolean`):

Enable a real headless browser to execute JavaScript before returning HTML. Turn ON for SPAs / dynamic sites (React, Vue, Angular) and protected stores like Amazon, eBay, Walmart. ON by default so the example URLs work out of the box. If the render backend fails for a URL, the Actor automatically retries that URL once without rendering (many pages, e.g. Amazon search, are server-rendered and load fine). Costs more API credits per request — turn OFF for simple static pages to save credits.

## `geoCode` (type: `string`):

Route the request through a proxy located in the selected country. Choose "Worldwide" for automatic selection.

## `regionalGeoCode` (type: `string`):

Route the request through a proxy located on the selected continent. A broader alternative to a specific country — leave on "Any" if you set a country above.

## `superProxy` (type: `boolean`):

Route requests through the residential & mobile proxy pool (scrape.do `super`). Best for heavily protected targets like LinkedIn, Instagram, TikTok or Zillow. Costs more credits per request.

## `device` (type: `string`):

Which device the request should imitate — desktop, mobile, or tablet. Changes the User-Agent and viewport the target site sees. Useful for scraping mobile layouts.

## `sessionId` (type: `string`):

Reuse the same exit IP across all requests that share this ID (scrape.do `sessionId`), for up to 5 minutes. Set any value (e.g. "session-1") when a target needs a stable IP across a multi-page flow such as login → listing. Leave empty to rotate IPs on every request.

## `setCookies` (type: `string`):

Cookies to send to the target site, as a single `name=value; name2=value2` string (scrape.do `setCookies`). Handy for scraping pages behind a cookie consent or a logged-in session.

## `disableRedirection` (type: `boolean`):

Return the first response without following 3xx redirects (scrape.do `disableRedirection`). Leave OFF for normal scraping.

## `forwardHeaders` (type: `boolean`):

Forward the headers you set in **Custom request headers** (Advanced) straight to the target site (scrape.do `forwardHeaders`) instead of letting the proxy manage them. Turn ON when a site needs a specific Authorization / Referer / Accept-Language you control.

## `extractRules` (type: `object`):

Optional mapping of field name → CSS selector. For every record the Actor returns the text of the first element matching each selector under `extractedFields`. The default below pulls the price from Amazon product pages (`.a-price .a-offscreen`). Examples — Amazon product: {"title": "#productTitle", "price": ".a-price .a-offscreen"}; eBay listing: {"title": "h1.x-item-title\_\_mainTitle", "price": ".x-price-primary"}.

## `waitUntil` (type: `string`):

When the headless browser considers the page 'loaded' before returning HTML (scrape.do `waitUntil`). `domcontentloaded` is fastest; `networkidle0` waits for all network activity to settle (best for heavy SPAs). Only applies when **Render JavaScript** is ON.

## `customWait` (type: `integer`):

Extra milliseconds to wait after the page loads before capturing it (scrape.do `customWait`) — lets late, JS-injected content (prices, reviews, lazy lists) settle. Only applies when **Render JavaScript** is ON.

## `waitSelector` (type: `string`):

Wait until this CSS selector appears in the DOM before returning (scrape.do `waitSelector`) — the most reliable way to ensure a specific element (e.g. `.product-price`) has rendered. Only applies when **Render JavaScript** is ON.

## `blockResources` (type: `boolean`):

Block images, CSS and fonts while rendering to load pages faster and cheaper (scrape.do `blockResources`, ON by default). Turn OFF if a site only works with assets loaded, or when taking screenshots you want fully styled. Only applies when **Render JavaScript** is ON.

## `viewportWidth` (type: `integer`):

Browser viewport width in pixels while rendering (scrape.do `width`). Leave empty for the provider default (1920). Only applies when **Render JavaScript** is ON.

## `viewportHeight` (type: `integer`):

Browser viewport height in pixels while rendering (scrape.do `height`). Leave empty for the provider default (1080). Only applies when **Render JavaScript** is ON.

## `playWithBrowser` (type: `array`):

Automate the headless browser before the page is captured (scrape.do `playWithBrowser`). A list of action steps run in order — click buttons, scroll infinite feeds, fill inputs, wait for elements, or execute JavaScript. Enabling this forces JavaScript rendering ON. Supported actions: `Click` (+`Selector`), `Wait` (+`Timeout` ms), `WaitSelector` (+`WaitSelector`,`Timeout`), `ScrollX`/`ScrollY` (+`Value`), `ScrollTo` (+`Selector`), `Fill` (+`Selector`,`Value`), `Execute` (+`Execute` JS). Leave empty unless you need interactions. Example — scroll an infinite feed, wait, then click 'load more': `[{"Action":"ScrollY","Value":3000},{"Action":"Wait","Timeout":2000},{"Action":"Click","Selector":"#load-more"}]`

## `screenShot` (type: `boolean`):

Return a screenshot of the visible viewport instead of HTML (scrape.do `screenShot`). The image is saved to the run's key-value store and the record gets `screenshotUrl` + `screenshotKey`. Forces JavaScript rendering ON.

## `fullScreenShot` (type: `boolean`):

Return a full-page screenshot (the entire scrollable page, not just the viewport — scrape.do `fullScreenShot`). Saved to the key-value store with `screenshotUrl` + `screenshotKey`. Wins over the viewport screenshot if both are on. Forces JavaScript rendering ON.

## `llmEnabled` (type: `boolean`):

After scraping each page, run an LLM over its content (summarize, classify, or extract structured data with your own prompt). Powered by OpenRouter. Leave OFF to skip LLM processing entirely.

## `llmModel` (type: `string`):

OpenRouter model used to process each page, listed cheapest to most expensive. The flash / flash-lite models with 1M context are ideal for reading and extracting from long scraped pages at low cost. Need a model not listed here? Use "Custom model slug" below.

## `llmModelCustom` (type: `string`):

Optional. Any OpenRouter model slug (e.g. "anthropic/claude-opus-4.8"). When set, this takes priority over the dropdown above — useful for models not in the list or newly released ones. See https://openrouter.ai/models for all slugs.

## `llmPrompt` (type: `string`):

Instruction applied to each page's content. Examples: "Summarize this page in 3 bullet points." or "Extract the product name, price and availability." The scraped page text is appended automatically.

## `llmJsonOutput` (type: `boolean`):

Ask the model to return a strict JSON object (sets response\_format=json\_object) and parse it into `llmResult`. Best paired with a prompt that describes the exact JSON fields you want.

## `llmMaxInputChars` (type: `integer`):

The page text is truncated to this many characters before being sent to the model, to control token cost. Increase for fuller context.

## `llmMaxTokens` (type: `integer`):

Maximum number of tokens in the LLM response.

## `llmTemperature` (type: `string`):

Sampling temperature 0.0–2.0. Lower is more deterministic (good for extraction); higher is more creative. Leave empty for the model default.

## `concurrencyPercentage` (type: `integer`):

How much of your plan's concurrent-request limit to use, as a percentage. The Actor reads your live plan limit from the API and scrapes with that percentage of your allowed concurrency. Example: a plan allowing 40 concurrent requests at 50% → 20 parallel requests. Default 100 = full speed (your entire plan limit).

## `maxRetries` (type: `integer`):

How many times to retry a failing URL (on network errors, rate limits, or 5xx responses) with exponential backoff before giving up.

## `requestTimeout` (type: `integer`):

Per-request timeout in seconds for the HTTP call to the Scraper API (client side).

## `scrapeTimeout` (type: `integer`):

Max time the Scraper API itself will spend fetching/rendering a page before giving up (scrape.do `timeout`, milliseconds). Leave empty for the provider default (60000). Raise it for slow, render-heavy pages.

## `customHeaders` (type: `object`):

Optional HTTP headers forwarded to the target site (e.g. a specific User-Agent or Accept-Language).

## `storeHtml` (type: `boolean`):

Include the full raw HTML in each dataset record. Disable to keep datasets small when you only need cleaned text or extracted fields.

## `openRouterApiKey` (type: `string`):

Optional. Only used when LLM processing is enabled. Provide your own OpenRouter API key to be billed directly by OpenRouter at their rates. Leave EMPTY to use Apify's hosted OpenRouter (https://apify.com/apify/openrouter) and pay with your Apify credits instead — no extra signup needed. Get an OpenRouter key at https://openrouter.ai/keys.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.amazon.com/s?k=wireless+earbuds"
    },
    {
      "url": "https://www.ebay.com/sch/i.html?_nkw=wireless+earbuds"
    }
  ],
  "scraperApi": "",
  "scraperApiQueries": [
    "https://www.amazon.com/dp/B0CHWRXH8B"
  ],
  "render": true,
  "geoCode": "",
  "regionalGeoCode": "",
  "superProxy": false,
  "device": "desktop",
  "disableRedirection": false,
  "forwardHeaders": false,
  "extractRules": {
    "title": "h1",
    "price": ".a-price .a-offscreen"
  },
  "waitUntil": "",
  "customWait": 0,
  "blockResources": true,
  "screenShot": false,
  "fullScreenShot": false,
  "llmEnabled": false,
  "llmModel": "google/gemini-3.1-flash-lite",
  "llmPrompt": "Summarize the key information on this page in 3-5 concise bullet points.",
  "llmJsonOutput": false,
  "llmMaxInputChars": 12000,
  "llmMaxTokens": 1024,
  "concurrencyPercentage": 100,
  "maxRetries": 3,
  "requestTimeout": 60,
  "storeHtml": true
}
```

# Actor output Schema

## `scrapedPages` (type: `string`):

One structured record per scraped URL — status, clean text, raw HTML, CSS-extracted fields and optional AI output.

## `planSnapshot` (type: `string`):

Scraper API plan limits and remaining quota captured at run start.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.amazon.com/s?k=wireless+earbuds"
        },
        {
            "url": "https://www.ebay.com/sch/i.html?_nkw=wireless+earbuds"
        }
    ],
    "scraperApiQueries": [
        "https://www.amazon.com/dp/B0CHWRXH8B"
    ],
    "extractRules": {
        "title": "h1",
        "price": ".a-price .a-offscreen"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/web-scraper-api-any-url-anti-bot-proxy-js-render-ai").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        { "url": "https://www.amazon.com/s?k=wireless+earbuds" },
        { "url": "https://www.ebay.com/sch/i.html?_nkw=wireless+earbuds" },
    ],
    "scraperApiQueries": ["https://www.amazon.com/dp/B0CHWRXH8B"],
    "extractRules": {
        "title": "h1",
        "price": ".a-price .a-offscreen",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/web-scraper-api-any-url-anti-bot-proxy-js-render-ai").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.amazon.com/s?k=wireless+earbuds"
    },
    {
      "url": "https://www.ebay.com/sch/i.html?_nkw=wireless+earbuds"
    }
  ],
  "scraperApiQueries": [
    "https://www.amazon.com/dp/B0CHWRXH8B"
  ],
  "extractRules": {
    "title": "h1",
    "price": ".a-price .a-offscreen"
  }
}' |
apify call fayoussef/web-scraper-api-any-url-anti-bot-proxy-js-render-ai --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/web-scraper-api-any-url-anti-bot-proxy-js-render-ai",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Web Scraper API - Any URL, Anti-Bot Proxy, JS Render & AI",
        "description": "Free web scraper API for any website. Rotating anti-bot proxies, JS rendering, screenshots, CSS + AI extraction. Clean HTML, Markdown and JSON.",
        "version": "1.0",
        "x-build-id": "WQgUyjgcKAOFEdlWl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~web-scraper-api-any-url-anti-bot-proxy-js-render-ai/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-web-scraper-api-any-url-anti-bot-proxy-js-render-ai",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fayoussef~web-scraper-api-any-url-anti-bot-proxy-js-render-ai/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-web-scraper-api-any-url-anti-bot-proxy-js-render-ai",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fayoussef~web-scraper-api-any-url-anti-bot-proxy-js-render-ai/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-web-scraper-api-any-url-anti-bot-proxy-js-render-ai",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "apiKey",
                    "startUrls"
                ],
                "properties": {
                    "apiKey": {
                        "title": "Scraper API Token",
                        "type": "string",
                        "description": "Your personal Scraper API token — the underlying scraping requests are billed to your own scrape.do account (this Actor itself is free). 👉 Don't have one? **[Create a free account and get 1,000 free monthly credits](https://scrape.do/?fpr=automationbyexperts)** — no credit card required. Paste your token from the dashboard once you sign up."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of URLs to scrape. Each URL is fetched through the Scraper API and pushed to the dataset as a structured record. Works on famous, heavily-protected sites — **Amazon, eBay, Walmart, Google, Google Maps, LinkedIn, Instagram, TikTok, Zillow, Yelp, Booking.com, Indeed, Crunchbase, Idealista** and thousands more. The defaults below are live Amazon and eBay search pages — swap in any product, search, profile, category, or listing URL you need. Tip: keep **Render JavaScript** ON for JS-heavy / protected sites.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "scraperApi": {
                        "title": "Ready-made structured scraper",
                        "enum": [
                            "",
                            "amazon-product",
                            "amazon-search",
                            "amazon-offers",
                            "google-search",
                            "google-maps",
                            "google-shopping",
                            "google-news",
                            "youtube",
                            "chatgpt"
                        ],
                        "type": "string",
                        "description": "Optionally switch to one of scrape.do's **Ready APIs** — dedicated endpoints that return clean, already-parsed JSON for a specific target instead of raw HTML. When set, the Actor scrapes the entries in **Ready API inputs** below (not Start URLs). Leave on \"Off\" for normal URL scraping. Note: Ready APIs run one-at-a-time per token and cost more credits per call (Google/YouTube ≈ 10, ChatGPT ≈ 25).",
                        "default": ""
                    },
                    "scraperApiQueries": {
                        "title": "Ready API inputs",
                        "type": "array",
                        "description": "The inputs to run through the selected **Ready-made structured scraper** — one per line. What each line should contain depends on the mode: a product URL/ASIN (Amazon product/offers), a keyword or query (Amazon/Google/YouTube search), or a prompt (ChatGPT). Ignored when the mode is \"Off\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "readyApiLanguage": {
                        "title": "Ready API language",
                        "type": "string",
                        "description": "Interface / results language for the Ready API (ISO 639-1, e.g. `en`, `es`, `de`). Maps to `language` for Amazon and `hl` for Google/YouTube. Leave empty for the provider default. Ignored by ChatGPT."
                    },
                    "amazonZipcode": {
                        "title": "Amazon ZIP / postal code",
                        "type": "string",
                        "description": "Amazon-only: a ZIP / postal code to get location-specific pricing, availability and delivery (Amazon Ready API `zipcode`, e.g. `90210`). Ignored by other modes."
                    },
                    "render": {
                        "title": "Render JavaScript",
                        "type": "boolean",
                        "description": "Enable a real headless browser to execute JavaScript before returning HTML. Turn ON for SPAs / dynamic sites (React, Vue, Angular) and protected stores like Amazon, eBay, Walmart. ON by default so the example URLs work out of the box. If the render backend fails for a URL, the Actor automatically retries that URL once without rendering (many pages, e.g. Amazon search, are server-rendered and load fine). Costs more API credits per request — turn OFF for simple static pages to save credits.",
                        "default": true
                    },
                    "geoCode": {
                        "title": "Geo-targeting location",
                        "enum": [
                            "",
                            "af",
                            "al",
                            "dz",
                            "as",
                            "ad",
                            "ao",
                            "ai",
                            "ag",
                            "ar",
                            "am",
                            "aw",
                            "au",
                            "at",
                            "az",
                            "bs",
                            "bh",
                            "bd",
                            "bb",
                            "by",
                            "be",
                            "bz",
                            "bj",
                            "bm",
                            "bt",
                            "bo",
                            "ba",
                            "bw",
                            "br",
                            "io",
                            "vg",
                            "bn",
                            "bg",
                            "bf",
                            "bi",
                            "kh",
                            "cm",
                            "ca",
                            "cv",
                            "ky",
                            "cf",
                            "td",
                            "cl",
                            "cn",
                            "co",
                            "km",
                            "cg",
                            "cd",
                            "cr",
                            "hr",
                            "cu",
                            "cw",
                            "cy",
                            "cz",
                            "ci",
                            "dk",
                            "dj",
                            "dm",
                            "do",
                            "ec",
                            "eg",
                            "sv",
                            "gq",
                            "er",
                            "ee",
                            "sz",
                            "et",
                            "fj",
                            "fi",
                            "fr",
                            "gf",
                            "pf",
                            "ga",
                            "gm",
                            "ge",
                            "de",
                            "gh",
                            "gi",
                            "gr",
                            "gl",
                            "gd",
                            "gp",
                            "gu",
                            "gt",
                            "gg",
                            "gn",
                            "gw",
                            "gy",
                            "ht",
                            "hn",
                            "hk",
                            "hu",
                            "is",
                            "in",
                            "id",
                            "ir",
                            "iq",
                            "ie",
                            "im",
                            "il",
                            "it",
                            "jm",
                            "jp",
                            "je",
                            "jo",
                            "kz",
                            "ke",
                            "ki",
                            "kw",
                            "kg",
                            "la",
                            "lv",
                            "lb",
                            "ls",
                            "lr",
                            "ly",
                            "li",
                            "lt",
                            "lu",
                            "mo",
                            "mg",
                            "mw",
                            "my",
                            "mv",
                            "ml",
                            "mt",
                            "mh",
                            "mq",
                            "mr",
                            "mu",
                            "yt",
                            "mx",
                            "fm",
                            "md",
                            "mc",
                            "mn",
                            "me",
                            "ms",
                            "ma",
                            "mz",
                            "mm",
                            "na",
                            "nr",
                            "np",
                            "nl",
                            "nc",
                            "nz",
                            "ni",
                            "ne",
                            "ng",
                            "mk",
                            "no",
                            "om",
                            "pk",
                            "pw",
                            "ps",
                            "pa",
                            "pg",
                            "py",
                            "pe",
                            "ph",
                            "pl",
                            "pt",
                            "pr",
                            "qa",
                            "ro",
                            "ru",
                            "rw",
                            "re",
                            "bl",
                            "kn",
                            "lc",
                            "mf",
                            "vc",
                            "ws",
                            "sm",
                            "sa",
                            "sn",
                            "rs",
                            "sc",
                            "sl",
                            "sg",
                            "sx",
                            "sk",
                            "si",
                            "sb",
                            "so",
                            "za",
                            "kr",
                            "ss",
                            "es",
                            "lk",
                            "sd",
                            "sr",
                            "se",
                            "ch",
                            "sy",
                            "st",
                            "tw",
                            "tj",
                            "tz",
                            "th",
                            "tl",
                            "tg",
                            "to",
                            "tt",
                            "tn",
                            "tm",
                            "tc",
                            "tv",
                            "tr",
                            "vi",
                            "ug",
                            "ua",
                            "ae",
                            "gb",
                            "us",
                            "uy",
                            "uz",
                            "vu",
                            "va",
                            "ve",
                            "vn",
                            "ye",
                            "zm",
                            "zw",
                            "ax"
                        ],
                        "type": "string",
                        "description": "Route the request through a proxy located in the selected country. Choose \"Worldwide\" for automatic selection.",
                        "default": ""
                    },
                    "regionalGeoCode": {
                        "title": "Geo-targeting continent",
                        "enum": [
                            "",
                            "europe",
                            "asia",
                            "africa",
                            "oceania",
                            "northamerica",
                            "southamerica"
                        ],
                        "type": "string",
                        "description": "Route the request through a proxy located on the selected continent. A broader alternative to a specific country — leave on \"Any\" if you set a country above.",
                        "default": ""
                    },
                    "superProxy": {
                        "title": "Use residential / premium proxy",
                        "type": "boolean",
                        "description": "Route requests through the residential & mobile proxy pool (scrape.do `super`). Best for heavily protected targets like LinkedIn, Instagram, TikTok or Zillow. Costs more credits per request.",
                        "default": false
                    },
                    "device": {
                        "title": "Device profile",
                        "enum": [
                            "desktop",
                            "mobile",
                            "tablet"
                        ],
                        "type": "string",
                        "description": "Which device the request should imitate — desktop, mobile, or tablet. Changes the User-Agent and viewport the target site sees. Useful for scraping mobile layouts.",
                        "default": "desktop"
                    },
                    "sessionId": {
                        "title": "Sticky session ID",
                        "type": "string",
                        "description": "Reuse the same exit IP across all requests that share this ID (scrape.do `sessionId`), for up to 5 minutes. Set any value (e.g. \"session-1\") when a target needs a stable IP across a multi-page flow such as login → listing. Leave empty to rotate IPs on every request."
                    },
                    "setCookies": {
                        "title": "Cookies",
                        "type": "string",
                        "description": "Cookies to send to the target site, as a single `name=value; name2=value2` string (scrape.do `setCookies`). Handy for scraping pages behind a cookie consent or a logged-in session."
                    },
                    "disableRedirection": {
                        "title": "Disable redirects",
                        "type": "boolean",
                        "description": "Return the first response without following 3xx redirects (scrape.do `disableRedirection`). Leave OFF for normal scraping.",
                        "default": false
                    },
                    "forwardHeaders": {
                        "title": "Forward my custom headers",
                        "type": "boolean",
                        "description": "Forward the headers you set in **Custom request headers** (Advanced) straight to the target site (scrape.do `forwardHeaders`) instead of letting the proxy manage them. Turn ON when a site needs a specific Authorization / Referer / Accept-Language you control.",
                        "default": false
                    },
                    "extractRules": {
                        "title": "Structured extraction rules (CSS)",
                        "type": "object",
                        "description": "Optional mapping of field name → CSS selector. For every record the Actor returns the text of the first element matching each selector under `extractedFields`. The default below pulls the price from Amazon product pages (`.a-price .a-offscreen`). Examples — Amazon product: {\"title\": \"#productTitle\", \"price\": \".a-price .a-offscreen\"}; eBay listing: {\"title\": \"h1.x-item-title__mainTitle\", \"price\": \".x-price-primary\"}."
                    },
                    "waitUntil": {
                        "title": "Wait until (page load event)",
                        "enum": [
                            "",
                            "domcontentloaded",
                            "load",
                            "networkidle0",
                            "networkidle2"
                        ],
                        "type": "string",
                        "description": "When the headless browser considers the page 'loaded' before returning HTML (scrape.do `waitUntil`). `domcontentloaded` is fastest; `networkidle0` waits for all network activity to settle (best for heavy SPAs). Only applies when **Render JavaScript** is ON.",
                        "default": ""
                    },
                    "customWait": {
                        "title": "Extra wait after load (ms)",
                        "minimum": 0,
                        "maximum": 35000,
                        "type": "integer",
                        "description": "Extra milliseconds to wait after the page loads before capturing it (scrape.do `customWait`) — lets late, JS-injected content (prices, reviews, lazy lists) settle. Only applies when **Render JavaScript** is ON.",
                        "default": 0
                    },
                    "waitSelector": {
                        "title": "Wait for CSS selector",
                        "type": "string",
                        "description": "Wait until this CSS selector appears in the DOM before returning (scrape.do `waitSelector`) — the most reliable way to ensure a specific element (e.g. `.product-price`) has rendered. Only applies when **Render JavaScript** is ON."
                    },
                    "blockResources": {
                        "title": "Block images / CSS / fonts (faster)",
                        "type": "boolean",
                        "description": "Block images, CSS and fonts while rendering to load pages faster and cheaper (scrape.do `blockResources`, ON by default). Turn OFF if a site only works with assets loaded, or when taking screenshots you want fully styled. Only applies when **Render JavaScript** is ON.",
                        "default": true
                    },
                    "viewportWidth": {
                        "title": "Viewport width (px)",
                        "minimum": 100,
                        "maximum": 3840,
                        "type": "integer",
                        "description": "Browser viewport width in pixels while rendering (scrape.do `width`). Leave empty for the provider default (1920). Only applies when **Render JavaScript** is ON."
                    },
                    "viewportHeight": {
                        "title": "Viewport height (px)",
                        "minimum": 100,
                        "maximum": 3840,
                        "type": "integer",
                        "description": "Browser viewport height in pixels while rendering (scrape.do `height`). Leave empty for the provider default (1080). Only applies when **Render JavaScript** is ON."
                    },
                    "playWithBrowser": {
                        "title": "Browser actions (click, scroll, type, wait, JS)",
                        "type": "array",
                        "description": "Automate the headless browser before the page is captured (scrape.do `playWithBrowser`). A list of action steps run in order — click buttons, scroll infinite feeds, fill inputs, wait for elements, or execute JavaScript. Enabling this forces JavaScript rendering ON. Supported actions: `Click` (+`Selector`), `Wait` (+`Timeout` ms), `WaitSelector` (+`WaitSelector`,`Timeout`), `ScrollX`/`ScrollY` (+`Value`), `ScrollTo` (+`Selector`), `Fill` (+`Selector`,`Value`), `Execute` (+`Execute` JS). Leave empty unless you need interactions. Example — scroll an infinite feed, wait, then click 'load more': `[{\"Action\":\"ScrollY\",\"Value\":3000},{\"Action\":\"Wait\",\"Timeout\":2000},{\"Action\":\"Click\",\"Selector\":\"#load-more\"}]`"
                    },
                    "screenShot": {
                        "title": "📸 Capture viewport screenshot",
                        "type": "boolean",
                        "description": "Return a screenshot of the visible viewport instead of HTML (scrape.do `screenShot`). The image is saved to the run's key-value store and the record gets `screenshotUrl` + `screenshotKey`. Forces JavaScript rendering ON.",
                        "default": false
                    },
                    "fullScreenShot": {
                        "title": "📸 Capture full-page screenshot",
                        "type": "boolean",
                        "description": "Return a full-page screenshot (the entire scrollable page, not just the viewport — scrape.do `fullScreenShot`). Saved to the key-value store with `screenshotUrl` + `screenshotKey`. Wins over the viewport screenshot if both are on. Forces JavaScript rendering ON.",
                        "default": false
                    },
                    "llmEnabled": {
                        "title": "🤖 Enable LLM processing",
                        "type": "boolean",
                        "description": "After scraping each page, run an LLM over its content (summarize, classify, or extract structured data with your own prompt). Powered by OpenRouter. Leave OFF to skip LLM processing entirely.",
                        "default": false
                    },
                    "llmModel": {
                        "title": "LLM model (cheapest → most capable)",
                        "enum": [
                            "anthropic/claude-opus-4.8-fast",
                            "anthropic/claude-opus-4.8",
                            "anthropic/claude-opus-4.7-fast",
                            "anthropic/claude-opus-4.7",
                            "anthropic/claude-sonnet-4.6",
                            "anthropic/claude-opus-4.6",
                            "anthropic/claude-opus-4.5",
                            "anthropic/claude-haiku-4.5",
                            "anthropic/claude-sonnet-4.5",
                            "anthropic/claude-opus-4.1",
                            "anthropic/claude-opus-4",
                            "anthropic/claude-sonnet-4",
                            "anthropic/claude-3-haiku",
                            "anthropic/claude-fable-5",
                            "google/gemini-3.1-flash-image",
                            "google/gemini-3-pro-image",
                            "google/gemini-3.5-flash",
                            "google/gemini-3.1-flash-lite",
                            "google/gemini-3.1-flash-lite-preview",
                            "google/gemini-3.1-flash-image-preview",
                            "google/gemini-3.1-pro-preview-customtools",
                            "google/gemini-3.1-pro-preview",
                            "google/gemini-3-flash-preview",
                            "google/gemini-3-pro-image-preview",
                            "google/gemini-2.5-flash-image",
                            "google/gemini-2.5-flash-lite-preview-09-2025",
                            "google/gemini-2.5-flash-lite",
                            "google/gemini-2.5-flash",
                            "google/gemini-2.5-pro",
                            "google/gemini-2.5-pro-preview",
                            "google/gemini-2.5-pro-preview-05-06",
                            "google/gemma-4-26b-a4b-it",
                            "google/gemma-4-31b-it",
                            "google/lyria-3-pro-preview",
                            "google/lyria-3-clip-preview",
                            "google/gemma-3n-e4b-it",
                            "google/gemma-3-4b-it",
                            "google/gemma-3-12b-it",
                            "google/gemma-3-27b-it",
                            "google/gemma-2-27b-it",
                            "google/gemma-4-26b-a4b-it:free",
                            "google/gemma-4-31b-it:free",
                            "openai/gpt-5.5-pro",
                            "openai/gpt-5.5",
                            "openai/gpt-5.4-image-2",
                            "openai/gpt-5.4-nano",
                            "openai/gpt-5.4-mini",
                            "openai/gpt-5.4-pro",
                            "openai/gpt-5.4",
                            "openai/gpt-5.3-chat",
                            "openai/gpt-5.3-codex",
                            "openai/gpt-5.2-codex",
                            "openai/gpt-5.2-chat",
                            "openai/gpt-5.2-pro",
                            "openai/gpt-5.2",
                            "openai/gpt-5.1-codex-max",
                            "openai/gpt-5.1",
                            "openai/gpt-5.1-chat",
                            "openai/gpt-5.1-codex",
                            "openai/gpt-5.1-codex-mini",
                            "openai/gpt-5-image-mini",
                            "openai/gpt-5-image",
                            "openai/o3-deep-research",
                            "openai/o4-mini-deep-research",
                            "openai/gpt-5-pro",
                            "openai/gpt-5-codex",
                            "openai/gpt-5-chat",
                            "openai/gpt-5",
                            "openai/gpt-5-mini",
                            "openai/gpt-5-nano",
                            "openai/o3-pro",
                            "openai/o4-mini-high",
                            "openai/o3",
                            "openai/o4-mini",
                            "openai/gpt-4.1",
                            "openai/gpt-4.1-mini",
                            "openai/gpt-4.1-nano",
                            "openai/gpt-4o-mini-search-preview",
                            "openai/gpt-4o-search-preview",
                            "openai/o3-mini-high",
                            "openai/o3-mini",
                            "openai/gpt-4o-2024-11-20",
                            "openai/gpt-4o-2024-08-06",
                            "openai/gpt-4o-mini",
                            "openai/gpt-4o-mini-2024-07-18",
                            "openai/gpt-4o",
                            "openai/gpt-4o-2024-05-13",
                            "openai/gpt-4-turbo",
                            "openai/gpt-4-turbo-preview",
                            "openai/gpt-4",
                            "openai/gpt-chat-latest",
                            "openai/gpt-audio",
                            "openai/gpt-audio-mini",
                            "openai/gpt-oss-safeguard-20b",
                            "openai/gpt-oss-120b",
                            "openai/gpt-oss-20b",
                            "openai/o1-pro",
                            "openai/o1",
                            "openai/gpt-3.5-turbo-0613",
                            "openai/gpt-3.5-turbo-instruct",
                            "openai/gpt-3.5-turbo-16k",
                            "openai/gpt-3.5-turbo",
                            "openai/gpt-oss-120b:free",
                            "openai/gpt-oss-20b:free",
                            "deepseek/deepseek-v3.2",
                            "deepseek/deepseek-v3.2-exp",
                            "deepseek/deepseek-v3.1-terminus",
                            "deepseek/deepseek-chat-v3.1",
                            "deepseek/deepseek-r1-0528",
                            "deepseek/deepseek-chat-v3-0324",
                            "deepseek/deepseek-r1-distill-llama-70b",
                            "deepseek/deepseek-r1",
                            "deepseek/deepseek-chat",
                            "deepseek/deepseek-v4-pro",
                            "deepseek/deepseek-v4-flash",
                            "x-ai/grok-4.3",
                            "x-ai/grok-4.20-multi-agent",
                            "x-ai/grok-4.20",
                            "x-ai/grok-build-0.1",
                            "meta-llama/llama-4-maverick",
                            "meta-llama/llama-4-scout",
                            "meta-llama/llama-guard-4-12b",
                            "meta-llama/llama-3.3-70b-instruct",
                            "meta-llama/llama-3.2-11b-vision-instruct",
                            "meta-llama/llama-3.2-1b-instruct",
                            "meta-llama/llama-3.2-3b-instruct",
                            "meta-llama/llama-3.1-70b-instruct",
                            "meta-llama/llama-3.1-8b-instruct",
                            "meta-llama/llama-3-8b-instruct",
                            "meta-llama/llama-3.3-70b-instruct:free",
                            "meta-llama/llama-3.2-3b-instruct:free",
                            "qwen/qwen3.7-plus",
                            "qwen/qwen3.7-max",
                            "qwen/qwen3.5-plus-20260420",
                            "qwen/qwen3.6-flash",
                            "qwen/qwen3.6-35b-a3b",
                            "qwen/qwen3.6-max-preview",
                            "qwen/qwen3.6-27b",
                            "qwen/qwen3.6-plus",
                            "qwen/qwen3.5-9b",
                            "qwen/qwen3.5-35b-a3b",
                            "qwen/qwen3.5-27b",
                            "qwen/qwen3.5-122b-a10b",
                            "qwen/qwen3.5-flash-02-23",
                            "qwen/qwen3.5-plus-02-15",
                            "qwen/qwen3.5-397b-a17b",
                            "qwen/qwen3-max-thinking",
                            "qwen/qwen3-coder-next",
                            "qwen/qwen3-vl-32b-instruct",
                            "qwen/qwen3-vl-8b-thinking",
                            "qwen/qwen3-vl-8b-instruct",
                            "qwen/qwen3-vl-30b-a3b-thinking",
                            "qwen/qwen3-vl-30b-a3b-instruct",
                            "qwen/qwen3-vl-235b-a22b-thinking",
                            "qwen/qwen3-vl-235b-a22b-instruct",
                            "qwen/qwen3-max",
                            "qwen/qwen3-coder-plus",
                            "qwen/qwen3-coder-flash",
                            "qwen/qwen3-next-80b-a3b-thinking",
                            "qwen/qwen3-next-80b-a3b-instruct",
                            "qwen/qwen3-30b-a3b-thinking-2507",
                            "qwen/qwen3-coder-30b-a3b-instruct",
                            "qwen/qwen3-30b-a3b-instruct-2507",
                            "qwen/qwen3-235b-a22b-thinking-2507",
                            "qwen/qwen3-coder",
                            "qwen/qwen3-235b-a22b-2507",
                            "qwen/qwen3-30b-a3b",
                            "qwen/qwen3-8b",
                            "qwen/qwen3-14b",
                            "qwen/qwen3-32b",
                            "qwen/qwen3-235b-a22b",
                            "qwen/qwen-2.5-coder-32b-instruct",
                            "qwen/qwen-2.5-7b-instruct",
                            "qwen/qwen-2.5-72b-instruct",
                            "qwen/qwen3-next-80b-a3b-instruct:free",
                            "qwen/qwen3-coder:free",
                            "qwen/qwen-plus-2025-07-28",
                            "qwen/qwen-plus-2025-07-28:thinking",
                            "qwen/qwen2.5-vl-72b-instruct",
                            "qwen/qwen-plus",
                            "mistralai/mistral-medium-3-5",
                            "mistralai/mistral-small-2603",
                            "mistralai/mistral-large-2512",
                            "mistralai/mistral-medium-3.1",
                            "mistralai/mistral-small-3.2-24b-instruct",
                            "mistralai/mistral-medium-3",
                            "mistralai/mistral-small-3.1-24b-instruct",
                            "mistralai/mistral-small-24b-instruct-2501",
                            "mistralai/mistral-large-2407",
                            "mistralai/mistral-large",
                            "mistralai/devstral-2512",
                            "mistralai/ministral-14b-2512",
                            "mistralai/ministral-8b-2512",
                            "mistralai/ministral-3b-2512",
                            "mistralai/voxtral-small-24b-2507",
                            "mistralai/codestral-2508",
                            "mistralai/mistral-saba",
                            "mistralai/mistral-nemo",
                            "mistralai/mixtral-8x22b-instruct",
                            "moonshotai/kimi-k2.7-code",
                            "moonshotai/kimi-k2.6",
                            "moonshotai/kimi-k2.5",
                            "moonshotai/kimi-k2-thinking",
                            "moonshotai/kimi-k2-0905",
                            "moonshotai/kimi-k2",
                            "z-ai/glm-5.2",
                            "z-ai/glm-5.1",
                            "z-ai/glm-5v-turbo",
                            "z-ai/glm-5-turbo",
                            "z-ai/glm-5",
                            "z-ai/glm-4.7-flash",
                            "z-ai/glm-4.7",
                            "z-ai/glm-4.6v",
                            "z-ai/glm-4.6",
                            "z-ai/glm-4.5v",
                            "z-ai/glm-4.5",
                            "z-ai/glm-4.5-air",
                            "perplexity/sonar-pro-search",
                            "perplexity/sonar-reasoning-pro",
                            "perplexity/sonar-pro",
                            "perplexity/sonar-deep-research",
                            "perplexity/sonar",
                            "cohere/command-a",
                            "cohere/command-r7b-12-2024",
                            "cohere/command-r-08-2024",
                            "cohere/command-r-plus-08-2024",
                            "cohere/north-mini-code:free",
                            "amazon/nova-2-lite-v1",
                            "amazon/nova-premier-v1",
                            "amazon/nova-lite-v1",
                            "amazon/nova-micro-v1",
                            "amazon/nova-pro-v1",
                            "nvidia/nemotron-3-ultra-550b-a55b",
                            "nvidia/nemotron-3-super-120b-a12b",
                            "nvidia/nemotron-3-nano-30b-a3b",
                            "nvidia/llama-3.3-nemotron-super-49b-v1.5",
                            "nvidia/nemotron-3.5-content-safety:free",
                            "nvidia/nemotron-3-ultra-550b-a55b:free",
                            "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
                            "nvidia/nemotron-3-super-120b-a12b:free",
                            "nvidia/nemotron-3-nano-30b-a3b:free",
                            "nvidia/nemotron-nano-12b-v2-vl:free",
                            "nvidia/nemotron-nano-9b-v2:free",
                            "minimax/minimax-m3",
                            "minimax/minimax-m2.7",
                            "minimax/minimax-m2.5",
                            "minimax/minimax-m2-her",
                            "minimax/minimax-m2.1",
                            "minimax/minimax-m2",
                            "minimax/minimax-m1",
                            "minimax/minimax-01",
                            "ai21/jamba-large-1.7",
                            "aion-labs/aion-2.0",
                            "aion-labs/aion-1.0",
                            "aion-labs/aion-1.0-mini",
                            "aion-labs/aion-rp-llama-3.1-8b",
                            "allenai/olmo-3-32b-think",
                            "anthracite-org/magnum-v4-72b",
                            "arcee-ai/trinity-large-thinking",
                            "arcee-ai/trinity-mini",
                            "arcee-ai/virtuoso-large",
                            "arcee-ai/coder-large",
                            "baidu/ernie-4.5-vl-424b-a47b",
                            "bytedance/ui-tars-1.5-7b",
                            "bytedance-seed/seed-2.0-lite",
                            "bytedance-seed/seed-2.0-mini",
                            "bytedance-seed/seed-1.6-flash",
                            "bytedance-seed/seed-1.6",
                            "cognitivecomputations/dolphin-mistral-24b-venice-edition:free",
                            "deepcogito/cogito-v2.1-671b",
                            "gryphe/mythomax-l2-13b",
                            "ibm-granite/granite-4.1-8b",
                            "ibm-granite/granite-4.0-h-micro",
                            "inception/mercury-2",
                            "inclusionai/ring-2.6-1t",
                            "inclusionai/ling-2.6-1t",
                            "inclusionai/ling-2.6-flash",
                            "inflection/inflection-3-pi",
                            "inflection/inflection-3-productivity",
                            "kwaipilot/kat-coder-pro-v2",
                            "liquid/lfm-2-24b-a2b",
                            "liquid/lfm-2.5-1.2b-thinking:free",
                            "liquid/lfm-2.5-1.2b-instruct:free",
                            "mancer/weaver",
                            "microsoft/phi-4-mini-instruct",
                            "microsoft/phi-4",
                            "microsoft/wizardlm-2-8x22b",
                            "morph/morph-v3-large",
                            "morph/morph-v3-fast",
                            "nex-agi/nex-n2-pro",
                            "nousresearch/hermes-4-70b",
                            "nousresearch/hermes-4-405b",
                            "nousresearch/hermes-3-llama-3.1-70b",
                            "nousresearch/hermes-3-llama-3.1-405b",
                            "nousresearch/hermes-3-llama-3.1-405b:free",
                            "openrouter/fusion",
                            "openrouter/owl-alpha",
                            "openrouter/pareto-code",
                            "openrouter/free",
                            "openrouter/bodybuilder",
                            "openrouter/auto",
                            "perceptron/perceptron-mk1",
                            "poolside/laguna-xs.2",
                            "poolside/laguna-m.1",
                            "poolside/laguna-xs.2:free",
                            "poolside/laguna-m.1:free",
                            "rekaai/reka-edge",
                            "rekaai/reka-flash-3",
                            "relace/relace-search",
                            "relace/relace-apply-3",
                            "sakana/fugu-ultra",
                            "sao10k/l3.1-70b-hanami-x1",
                            "sao10k/l3.3-euryale-70b",
                            "sao10k/l3.1-euryale-70b",
                            "sao10k/l3-lunaris-8b",
                            "stepfun/step-3.7-flash",
                            "stepfun/step-3.5-flash",
                            "switchpoint/router",
                            "tencent/hy3-preview",
                            "tencent/hunyuan-a13b-instruct",
                            "thedrummer/cydonia-24b-v4.1",
                            "thedrummer/skyfall-36b-v2",
                            "thedrummer/unslopnemo-12b",
                            "thedrummer/rocinante-12b",
                            "undi95/remm-slerp-l2-13b",
                            "upstage/solar-pro-3",
                            "writer/palmyra-x5",
                            "xiaomi/mimo-v2.5-pro",
                            "xiaomi/mimo-v2.5"
                        ],
                        "type": "string",
                        "description": "OpenRouter model used to process each page, listed cheapest to most expensive. The flash / flash-lite models with 1M context are ideal for reading and extracting from long scraped pages at low cost. Need a model not listed here? Use \"Custom model slug\" below.",
                        "default": "google/gemini-3.1-flash-lite"
                    },
                    "llmModelCustom": {
                        "title": "Custom model slug (optional, overrides the dropdown)",
                        "type": "string",
                        "description": "Optional. Any OpenRouter model slug (e.g. \"anthropic/claude-opus-4.8\"). When set, this takes priority over the dropdown above — useful for models not in the list or newly released ones. See https://openrouter.ai/models for all slugs."
                    },
                    "llmPrompt": {
                        "title": "LLM prompt / instruction",
                        "type": "string",
                        "description": "Instruction applied to each page's content. Examples: \"Summarize this page in 3 bullet points.\" or \"Extract the product name, price and availability.\" The scraped page text is appended automatically.",
                        "default": "Summarize the key information on this page in 3-5 concise bullet points."
                    },
                    "llmJsonOutput": {
                        "title": "Force JSON output",
                        "type": "boolean",
                        "description": "Ask the model to return a strict JSON object (sets response_format=json_object) and parse it into `llmResult`. Best paired with a prompt that describes the exact JSON fields you want.",
                        "default": false
                    },
                    "llmMaxInputChars": {
                        "title": "Max input characters sent to LLM",
                        "minimum": 500,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "The page text is truncated to this many characters before being sent to the model, to control token cost. Increase for fuller context.",
                        "default": 12000
                    },
                    "llmMaxTokens": {
                        "title": "Max output tokens",
                        "minimum": 1,
                        "maximum": 16000,
                        "type": "integer",
                        "description": "Maximum number of tokens in the LLM response.",
                        "default": 1024
                    },
                    "llmTemperature": {
                        "title": "LLM temperature",
                        "type": "string",
                        "description": "Sampling temperature 0.0–2.0. Lower is more deterministic (good for extraction); higher is more creative. Leave empty for the model default."
                    },
                    "concurrencyPercentage": {
                        "title": "Concurrency (% of your plan)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How much of your plan's concurrent-request limit to use, as a percentage. The Actor reads your live plan limit from the API and scrapes with that percentage of your allowed concurrency. Example: a plan allowing 40 concurrent requests at 50% → 20 parallel requests. Default 100 = full speed (your entire plan limit).",
                        "default": 100
                    },
                    "maxRetries": {
                        "title": "Max retries per URL",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many times to retry a failing URL (on network errors, rate limits, or 5xx responses) with exponential backoff before giving up.",
                        "default": 3
                    },
                    "requestTimeout": {
                        "title": "Request timeout (seconds)",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Per-request timeout in seconds for the HTTP call to the Scraper API (client side).",
                        "default": 60
                    },
                    "scrapeTimeout": {
                        "title": "Scraper API timeout (ms)",
                        "minimum": 5000,
                        "maximum": 120000,
                        "type": "integer",
                        "description": "Max time the Scraper API itself will spend fetching/rendering a page before giving up (scrape.do `timeout`, milliseconds). Leave empty for the provider default (60000). Raise it for slow, render-heavy pages."
                    },
                    "customHeaders": {
                        "title": "Custom request headers",
                        "type": "object",
                        "description": "Optional HTTP headers forwarded to the target site (e.g. a specific User-Agent or Accept-Language)."
                    },
                    "storeHtml": {
                        "title": "Store raw HTML in dataset",
                        "type": "boolean",
                        "description": "Include the full raw HTML in each dataset record. Disable to keep datasets small when you only need cleaned text or extracted fields.",
                        "default": true
                    },
                    "openRouterApiKey": {
                        "title": "OpenRouter API key (optional)",
                        "type": "string",
                        "description": "Optional. Only used when LLM processing is enabled. Provide your own OpenRouter API key to be billed directly by OpenRouter at their rates. Leave EMPTY to use Apify's hosted OpenRouter (https://apify.com/apify/openrouter) and pay with your Apify credits instead — no extra signup needed. Get an OpenRouter key at https://openrouter.ai/keys."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```