# Google SERP Scraper (`datascraperes/google-serp-scraper`) Actor

Scrape Google organic search results by query, country, language, and page range. Get clean SERP data including position, title, URL, and description, with pay-per-result pricing and no browser required.

- **URL**: https://apify.com/datascraperes/google-serp-scraper.md
- **Developed by:** [DataScraperES](https://apify.com/datascraperes) (community)
- **Categories:** SEO tools, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.15 / 1,000 serp results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Google SERP Scraper

Google SERP Scraper extracts clean organic Google Search results for one or more queries. Use it to collect SERP positions, titles, URLs, and snippets by country, language, and page range without running a browser.

The Actor is built for lightweight Google results monitoring, SEO research, lead generation, content research, and competitor analysis. It stores one dataset item per organic result and can also include People Also Ask data when Google returns it.

### What can Google SERP Scraper do?

- Scrape Google organic search results for one or many queries.
- Target Google by language with `language` and country with `country`.
- Collect pages 1-10 of Google results.
- Return clean fields: `query`, `page`, `position`, `title`, `url`, and `description`.
- Save People Also Ask data as extra context when available.
- Run without Playwright, Puppeteer, Selenium, or a headless browser.
- Use managed proxy infrastructure configured by the Actor owner.
- Retry blocked, rate-limited, empty, or degraded responses automatically.
- Re-run failed pages at the end of the run with a recovery pass.
- Export results from Apify Dataset as JSON, CSV, Excel, HTML, RSS, or through the API.

### Use cases

Google SERP Scraper is useful when you need structured Google results at scale:

- SEO rank tracking for keywords and markets.
- Competitor research and SERP analysis.
- Content gap and topic research.
- Lead generation from search results.
- Monitoring changes in organic results over time.
- Building datasets for marketing, SEO, or research workflows.
- Enriching internal tools with Google result URLs and snippets.

### Input

Configure the Actor in the Input tab. The main fields are:

| Field | Type | Required | Default | Description |
|---|---|---:|---|---|
| `queries` | array of strings | Yes | none | Search queries to scrape. Enter one query per line. |
| `startPage` | integer | No | `1` | First Google results page to scrape. |
| `endPage` | integer | No | `1` | Last Google results page to scrape. Maximum: `10`. |
| `language` | string | No | `es` | Google interface/search language code, used as `hl`. |
| `country` | string | No | `es` | Google country code, used as `gl` and proxy geolocation fallback. |

#### Example input

```json
{
  "queries": [
    "best web hosting 2026",
    "seo tools for beginners"
  ],
  "startPage": 1,
  "endPage": 3,
  "language": "en",
  "country": "us"
}
````

This input scrapes two queries, pages 1-3, using English Google results for the United States.

### Output

Each organic result is saved as one dataset item.

```json
{
  "query": "best web hosting 2026",
  "page": 1,
  "position": 1,
  "title": "Best Web Hosting 2026 - Full Comparison",
  "url": "https://example.com/best-web-hosting/",
  "description": "Snippet text shown in Google results."
}
```

#### Output fields

| Field | Type | Description |
|---|---|---|
| `query` | string | The query used for this Google search. |
| `page` | integer | Google results page number. |
| `position` | integer | Organic result position across the requested page range. |
| `title` | string | Result title shown by Google. |
| `url` | string | Destination URL extracted from the result. |
| `description` | string | Google snippet text when available. |

When People Also Ask data is found, the Actor may save one additional dataset item for that query/page:

```json
{
  "query": "best web hosting 2026",
  "page": 1,
  "type": "people_also_ask",
  "people_also_ask": [
    {
      "question": "What is the best hosting provider?",
      "answer": "Short answer extracted from Google.",
      "source_title": "Example source",
      "source_url": "https://example.com/"
    }
  ]
}
```

People Also Ask items are included as extra context and are not charged as SERP result events.

### Pricing

This Actor uses pay-per-event pricing.

| Event | What is charged | Price |
|---|---|---:|
| `serp-result` | One organic Google SERP result saved to the dataset | `$0.15 / 1,000 results` |

Platform usage is included in the result price. Users should not be charged separate usage costs.

### Proxy and infrastructure

Users do not need to configure proxies. The Actor owner manages the runtime proxy setup and platform infrastructure.

The `country` input still matters: it is sent to Google as the `gl` parameter and is also used as proxy geolocation when fallback proxy infrastructure is needed.

### How retries and recovery work

Google can sometimes return rate limits, empty HTML, degraded HTML, or changed markup. The Actor handles this by:

1. Rotating through tested User-Agent strings.
2. Retrying failed requests with fresh proxy URLs when the proxy provider supports rotation.
3. Retrying blocked, non-200, timeout, degraded, and empty-parse responses.
4. Running a recovery pass at the end for pages that returned 0 results in the first pass.

The run does not stop on the first bad page. It continues, records progress in status messages, and reports the final number of successful and failed pages.

### Limits and notes

- The maximum page range is 1-10.
- Ads, shopping boxes, local packs, maps, and knowledge panels are not included in the main output.
- Google result pages can change frequently; two runs with the same input may return different positions or snippets.
- Some results may not include a description if Google does not return a normal snippet for that result.
- Google markup can change over time, so production runs should be monitored.

### Troubleshooting

| Problem | What it means | What to check |
|---|---|---|
| `0 results` for a page | Google returned a blocked, empty, or unsupported response | Check the final status; the recovery pass may retry and recover it. |
| Fewer than 10 results on a page | Google returned fewer organic results for that page | This is normal for some queries/pages. |
| Missing descriptions | Google did not return a normal snippet for that result | The title and URL can still be valid. |
| Pay-per-event warning | Pricing event is not configured correctly | Contact the Actor owner or check the monetization settings. |

### API usage

You can run the Actor from the Apify API or Apify client libraries. After the run finishes, read the default dataset items.

Example input payload:

```json
{
  "queries": ["javascript"],
  "startPage": 1,
  "endPage": 10,
  "language": "en",
  "country": "us"
}
```

The dataset can be downloaded from Apify Console or consumed through the dataset API.

### Data responsibility

This Actor extracts publicly visible Google Search result data. Users are responsible for using the output lawfully and respecting applicable regulations, website terms, and privacy requirements in their jurisdiction.

# Actor input Schema

## `queries` (type: `array`):

One or more search queries to scrape from Google.

## `startPage` (type: `integer`):

First Google results page to scrape (1 = positions 1–10).

## `endPage` (type: `integer`):

Last Google results page to scrape. E.g. startPage=1, endPage=3 scrapes pages 1, 2 and 3 (positions 1–30).

## `language` (type: `string`):

Language code for the search (select a language from the list).

## `country` (type: `string`):

Country code for the search and proxy geolocation (select a country from the list).

## Actor input object example

```json
{
  "queries": [
    "apify web scraping"
  ],
  "startPage": 1,
  "endPage": 1,
  "language": "es",
  "country": "es"
}
```

# Actor output Schema

## `results` (type: `string`):

Organic Google SERP results stored in the default dataset.

# 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 = {
    "queries": [
        "apify web scraping"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascraperes/google-serp-scraper").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 = { "queries": ["apify web scraping"] }

# Run the Actor and wait for it to finish
run = client.actor("datascraperes/google-serp-scraper").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 '{
  "queries": [
    "apify web scraping"
  ]
}' |
apify call datascraperes/google-serp-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datascraperes/google-serp-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google SERP Scraper",
        "description": "Scrape Google organic search results by query, country, language, and page range. Get clean SERP data including position, title, URL, and description, with pay-per-result pricing and no browser required.",
        "version": "1.0",
        "x-build-id": "SWkp3426NHAIOOT7t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datascraperes~google-serp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datascraperes-google-serp-scraper",
                "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/datascraperes~google-serp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datascraperes-google-serp-scraper",
                "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/datascraperes~google-serp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datascraperes-google-serp-scraper",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "One or more search queries to scrape from Google.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startPage": {
                        "title": "Start Page",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "First Google results page to scrape (1 = positions 1–10).",
                        "default": 1
                    },
                    "endPage": {
                        "title": "End Page",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Last Google results page to scrape. E.g. startPage=1, endPage=3 scrapes pages 1, 2 and 3 (positions 1–30).",
                        "default": 1
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "aa",
                            "ab",
                            "ae",
                            "af",
                            "ak",
                            "am",
                            "an",
                            "ar",
                            "as",
                            "av",
                            "ay",
                            "az",
                            "ba",
                            "be",
                            "bg",
                            "bi",
                            "bm",
                            "bn",
                            "bo",
                            "br",
                            "bs",
                            "ca",
                            "ce",
                            "ch",
                            "co",
                            "cr",
                            "cs",
                            "cu",
                            "cv",
                            "cy",
                            "da",
                            "de",
                            "dv",
                            "dz",
                            "ee",
                            "el",
                            "en",
                            "eo",
                            "es",
                            "et",
                            "eu",
                            "fa",
                            "ff",
                            "fi",
                            "fj",
                            "fo",
                            "fr",
                            "fy",
                            "ga",
                            "gd",
                            "gl",
                            "gn",
                            "gu",
                            "gv",
                            "ha",
                            "he",
                            "hi",
                            "ho",
                            "hr",
                            "ht",
                            "hu",
                            "hy",
                            "hz",
                            "ia",
                            "id",
                            "ie",
                            "ig",
                            "ii",
                            "ik",
                            "io",
                            "is",
                            "it",
                            "iu",
                            "ja",
                            "jv",
                            "ka",
                            "kg",
                            "ki",
                            "kj",
                            "kk",
                            "kl",
                            "km",
                            "kn",
                            "ko",
                            "kr",
                            "ks",
                            "ku",
                            "kv",
                            "kw",
                            "ky",
                            "la",
                            "lb",
                            "lg",
                            "li",
                            "ln",
                            "lo",
                            "lt",
                            "lu",
                            "lv",
                            "mg",
                            "mh",
                            "mi",
                            "mk",
                            "ml",
                            "mn",
                            "mr",
                            "ms",
                            "mt",
                            "my",
                            "na",
                            "nb",
                            "nd",
                            "ne",
                            "ng",
                            "nl",
                            "nn",
                            "no",
                            "nr",
                            "nv",
                            "ny",
                            "oc",
                            "oj",
                            "om",
                            "or",
                            "os",
                            "pa",
                            "pi",
                            "pl",
                            "ps",
                            "pt",
                            "qu",
                            "rm",
                            "rn",
                            "ro",
                            "ru",
                            "rw",
                            "sa",
                            "sc",
                            "sd",
                            "se",
                            "sg",
                            "sh",
                            "si",
                            "sk",
                            "sl",
                            "sm",
                            "sn",
                            "so",
                            "sq",
                            "sr",
                            "ss",
                            "st",
                            "su",
                            "sv",
                            "sw",
                            "ta",
                            "te",
                            "tg",
                            "th",
                            "ti",
                            "tk",
                            "tl",
                            "tn",
                            "to",
                            "tr",
                            "ts",
                            "tt",
                            "tw",
                            "ty",
                            "ug",
                            "uk",
                            "ur",
                            "uz",
                            "ve",
                            "vi",
                            "vo",
                            "wa",
                            "wo",
                            "xh",
                            "yi",
                            "yo",
                            "za",
                            "zh",
                            "zu"
                        ],
                        "type": "string",
                        "description": "Language code for the search (select a language from the list).",
                        "default": "es"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "ac",
                            "ad",
                            "ae",
                            "af",
                            "ag",
                            "ai",
                            "al",
                            "am",
                            "ao",
                            "aq",
                            "ar",
                            "as",
                            "at",
                            "au",
                            "aw",
                            "ax",
                            "az",
                            "ba",
                            "bb",
                            "bd",
                            "be",
                            "bf",
                            "bg",
                            "bh",
                            "bi",
                            "bj",
                            "bl",
                            "bm",
                            "bn",
                            "bo",
                            "bq",
                            "br",
                            "bs",
                            "bt",
                            "bv",
                            "bw",
                            "by",
                            "bz",
                            "ca",
                            "cc",
                            "cd",
                            "cf",
                            "cg",
                            "ch",
                            "ci",
                            "ck",
                            "cl",
                            "cm",
                            "cn",
                            "co",
                            "cp",
                            "cq",
                            "cr",
                            "cu",
                            "cv",
                            "cw",
                            "cx",
                            "cy",
                            "cz",
                            "de",
                            "dg",
                            "dj",
                            "dk",
                            "dm",
                            "do",
                            "dz",
                            "ea",
                            "ec",
                            "ee",
                            "eg",
                            "eh",
                            "er",
                            "es",
                            "et",
                            "fi",
                            "fj",
                            "fk",
                            "fm",
                            "fo",
                            "fr",
                            "ga",
                            "gb",
                            "gd",
                            "ge",
                            "gf",
                            "gg",
                            "gh",
                            "gi",
                            "gl",
                            "gm",
                            "gn",
                            "gp",
                            "gq",
                            "gr",
                            "gs",
                            "gt",
                            "gu",
                            "gw",
                            "gy",
                            "hk",
                            "hm",
                            "hn",
                            "hr",
                            "ht",
                            "hu",
                            "ic",
                            "id",
                            "ie",
                            "il",
                            "im",
                            "in",
                            "io",
                            "iq",
                            "ir",
                            "is",
                            "it",
                            "je",
                            "jm",
                            "jo",
                            "jp",
                            "ke",
                            "kg",
                            "kh",
                            "ki",
                            "km",
                            "kn",
                            "kp",
                            "kr",
                            "kw",
                            "ky",
                            "kz",
                            "la",
                            "lb",
                            "lc",
                            "li",
                            "lk",
                            "lr",
                            "ls",
                            "lt",
                            "lu",
                            "lv",
                            "ly",
                            "ma",
                            "mc",
                            "md",
                            "me",
                            "mf",
                            "mg",
                            "mh",
                            "mk",
                            "ml",
                            "mm",
                            "mn",
                            "mo",
                            "mp",
                            "mq",
                            "mr",
                            "ms",
                            "mt",
                            "mu",
                            "mv",
                            "mw",
                            "mx",
                            "my",
                            "mz",
                            "na",
                            "nc",
                            "ne",
                            "nf",
                            "ng",
                            "ni",
                            "nl",
                            "no",
                            "np",
                            "nr",
                            "nu",
                            "nz",
                            "om",
                            "pa",
                            "pe",
                            "pf",
                            "pg",
                            "ph",
                            "pk",
                            "pl",
                            "pm",
                            "pn",
                            "pr",
                            "ps",
                            "pt",
                            "pw",
                            "py",
                            "qa",
                            "qo",
                            "re",
                            "ro",
                            "rs",
                            "ru",
                            "rw",
                            "sa",
                            "sb",
                            "sc",
                            "sd",
                            "se",
                            "sg",
                            "sh",
                            "si",
                            "sj",
                            "sk",
                            "sl",
                            "sm",
                            "sn",
                            "so",
                            "sr",
                            "ss",
                            "st",
                            "sv",
                            "sx",
                            "sy",
                            "sz",
                            "ta",
                            "tc",
                            "td",
                            "tf",
                            "tg",
                            "th",
                            "tj",
                            "tk",
                            "tl",
                            "tm",
                            "tn",
                            "to",
                            "tr",
                            "tt",
                            "tv",
                            "tw",
                            "tz",
                            "ua",
                            "ug",
                            "um",
                            "un",
                            "us",
                            "uy",
                            "uz",
                            "va",
                            "vc",
                            "ve",
                            "vg",
                            "vi",
                            "vn",
                            "vu",
                            "wf",
                            "ws",
                            "xk",
                            "ye",
                            "yt",
                            "za",
                            "zm",
                            "zw"
                        ],
                        "type": "string",
                        "description": "Country code for the search and proxy geolocation (select a country from the list).",
                        "default": "es"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
