# Google Jobs Scraper — Salary, Apply Links & MCP-Ready (`khadinakbar/google-jobs-scraper`) Actor

Extract job listings from Google Jobs. Returns title, company, location, salary (parsed min/max), full description, apply link, employment type & more. Bulk queries supported. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/khadinakbar/google-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 7 total users, 3 monthly users, 92.9% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 job 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.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 Jobs Scraper — Fast, Cheap & MCP-Ready

Extract structured job listings from Google Jobs at **$3.00 per 1,000 results** — the most affordable Google Jobs scraper on Apify. Get job titles, companies, locations, full descriptions, parsed salary ranges (min/max numbers), apply links, and more in one clean JSON dataset.

Designed for recruiters, HR tech platforms, job board builders, and AI agents that need reliable, structured employment data at scale.

---

### Why This Scraper?

Most Google Jobs scrapers on Apify charge $150 per 1,000 results and still earn 1-2 star ratings from frustrated users. This actor is built differently:

- **50× cheaper** — $3/1,000 jobs vs $150/1,000 from the leading competitor
- **Salary parsing built-in** — raw strings like `"$120,000–$180,000 a year"` become `salary_min: 120000`, `salary_max: 180000`, `salary_period: "YEAR"` — ready for direct filtering and sorting
- **Multi-query batch runs** — search 10 job titles across 5 cities in a single actor run
- **Full descriptions** — clicks into each job's detail panel to get the complete description, qualifications, responsibilities, and benefits
- **Lightweight** — runs in 1GB RAM and finishes typical searches in under 5 minutes (competitors require 4GB RAM and 1-hour timeouts)
- **MCP-optimized** — complete dataset schema with field-level descriptions, so Claude, ChatGPT, and other AI agents understand your output immediately

---

### What Data You Get

Each job listing returns a consistent JSON object:

```json
{
    "job_title": "Senior Software Engineer",
    "company_name": "Stripe",
    "location": "San Francisco, CA",
    "is_remote": false,
    "employment_type": "FULLTIME",
    "salary_range": "$160,000–$220,000 a year",
    "salary_min": 160000,
    "salary_max": 220000,
    "salary_period": "YEAR",
    "date_posted": "2 days ago",
    "job_description": "We are looking for a Senior Software Engineer to help build...",
    "highlights": {
        "qualifications": ["5+ years of backend experience", "Strong Python/Go skills"],
        "responsibilities": ["Design and own core payment infrastructure", "Mentor junior engineers"],
        "benefits": ["Competitive equity", "Health, dental, vision", "Remote-friendly"]
    },
    "apply_link": "https://stripe.com/jobs/listing/senior-software-engineer/12345",
    "via_platform": "LinkedIn",
    "search_query": "software engineer San Francisco",
    "source_url": "https://www.google.com/search?q=software+engineer+San+Francisco&ibp=htl%3Bjobs",
    "scraped_at": "2026-03-31T14:23:45.123Z"
}
````

***

### Input Parameters

#### `searchQueries` (array of strings) — recommended

The job titles, skills, or keyword phrases to search on Google Jobs. Pass multiple queries to run batch searches in one actor run.

```json
{
    "searchQueries": [
        "software engineer New York",
        "product manager remote",
        "data scientist Chicago"
    ],
    "maxResults": 150
}
```

#### `startUrls` (array of URLs) — optional

Paste specific Google Jobs search URLs if you have them. Useful for repeating a search you've already configured in your browser.

```json
{
    "startUrls": [
        { "url": "https://www.google.com/search?q=nurse+practitioner&ibp=htl;jobs" }
    ]
}
```

#### `maxResults` (integer, 1–500, default: 50)

Maximum total job listings to extract across all queries. Each result costs $0.003. 100 results = $0.30.

#### `datePosted` (string, default: "any")

Filter jobs by posting recency: `any`, `today`, `3days`, `week`, `month`.

#### `employmentType` (string, default: "any")

Filter by contract type: `any`, `FULLTIME`, `PARTTIME`, `CONTRACTOR`, `INTERN`.

#### `remoteOnly` (boolean, default: false)

When enabled, appends "remote" to all queries and marks all results `is_remote: true`.

#### `proxyCountry` (string, default: "US")

2-letter country code for the residential proxy location. Controls which regional Google Jobs index is scraped (e.g. `"GB"` for UK jobs, `"CA"` for Canadian jobs).

***

### Use Cases

**Job board builders** — Pull fresh listings from Google Jobs daily and populate your own platform. Filter by location, type, and recency with a single API call.

**Recruitment & HR tech** — Track competitor hiring activity, monitor which companies are scaling in a given market, and identify salary benchmarks by role.

**Labour market research** — Map hiring trends across geographies. The `salary_min`/`salary_max` fields allow you to build salary distribution charts without writing any parsing code.

**AI agent pipelines** — This actor is MCP-compatible. Tell Claude or GPT "find 50 remote data science jobs posted this week" and it will call this actor and return structured results you can immediately use.

**Talent sourcing** — Use multi-query batch runs to search for 20 different roles across 10 cities in one single actor run. Cross-reference results to find companies actively hiring across multiple departments.

***

### Cost & Performance

| Scenario | Jobs | Estimated Cost | Est. Run Time |
|---|---|---|---|
| Quick spot check | 10 | $0.03 | ~1 min |
| Standard search | 50 | $0.15 | ~3 min |
| Batch (5 queries) | 200 | $0.60 | ~8 min |
| Large batch (10 queries) | 500 | $1.50 | ~15 min |

All costs include Apify compute. Your actor plan determines the platform base charge — see [Apify pricing](https://apify.com/pricing) for details.

***

### Pricing

This actor uses **Pay-Per-Event** pricing: you only pay for the jobs you actually extract.

**$0.003 per job result** ($3.00 per 1,000 jobs)

There are no monthly fees, no minimum spend, and no charge for failed runs or empty results. Your Apify subscription tier may apply volume discounts automatically.

***

### Technical Notes

**Why residential proxies?** Google aggressively blocks datacenter IP ranges on SERP pages. This actor uses residential proxies by default to ensure reliable results. Proxy costs are included in the per-result price.

**Selector resilience** — The actor uses multiple CSS selector fallbacks at every extraction step. If Google updates a class name, the actor attempts alternative selectors before failing. The most likely point of breakage after a Google UI change is the card-level extraction; if you notice zero results, open an issue and it will be patched within 24–48 hours.

**CAPTCHA handling** — If Google serves a CAPTCHA (rare with residential proxies), the actor skips that request and logs a warning. It will not crash; it continues processing other queries.

**Memory requirement** — 1,024 MB. This is significantly lower than competing actors that require 4,096 MB.

***

### Integration Examples

#### Apify API (Node.js)

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('khadinakbar/google-jobs-scraper').call({
    searchQueries: ['frontend developer London', 'react developer remote'],
    maxResults: 100,
    datePosted: 'week',
    employmentType: 'FULLTIME',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

run = client.actor("khadinakbar/google-jobs-scraper").call(run_input={
    "searchQueries": ["data engineer New York"],
    "maxResults": 50,
    "remoteOnly": False,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["job_title"], item["salary_min"], item["salary_max"])
```

#### Make (Integromat) / Zapier

Use the **Apify** module to call this actor with your search queries. Map the output fields to any downstream service — Google Sheets, Airtable, Notion, Slack, or a CRM.

***

### Limitations

- Google does not always display salary data. The `salary_range`, `salary_min`, and `salary_max` fields will be `null` for listings where the employer did not disclose pay.
- Google Jobs is limited to ~100 results per query by design. For more results, use multiple specific queries (e.g. split by city or role level).
- This actor does not bypass authentication — it only accesses the public Google Jobs search, no login required.
- If Google implements a new anti-bot challenge, success rate may temporarily dip. Issues are typically resolved within 48 hours.

***

### Support & Feedback

Found a bug or want a new feature? Open an issue directly in the actor's **Issues** tab — responses within 24 hours.

If this actor saved you time or money, please ⭐ leave a review — it helps other users find it and keeps this actor maintained.

***

### Changelog

**v0.1** — Initial release. Multi-query batch runs, salary parsing, full description extraction, MCP dataset schema, PAY\_PER\_EVENT pricing at $0.003/job.

# Actor input Schema

## `searchQueries` (type: `array`):

Use this field when the user provides job titles, skills, or keyword phrases to search. Accepts multiple queries — the actor runs them all in one go. Example: \["software engineer New York", "product manager remote"]. Use startUrls instead when the user provides a direct Google Jobs URL.

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

Use this field when the user provides a specific Google Jobs URL (e.g. https://www.google.com/search?q=nurse\&ibp=htl;jobs). Do NOT use this when the user describes a job role or keyword — use searchQueries instead.

## `maxResults` (type: `integer`):

Maximum total number of job listings to extract across all queries. Must be between 1 and 500. Default: 50. Each result costs $0.003 — so 100 results costs $0.30.

## `datePosted` (type: `string`):

Filter jobs by how recently they were posted. 'any' returns all results. 'today' returns jobs posted in the last 24 hours. 'week' returns jobs from the past 7 days.

## `employmentType` (type: `string`):

Filter by job type. Use 'FULLTIME' for permanent full-time roles, 'PARTTIME' for part-time, 'CONTRACTOR' for contract/freelance work, 'INTERN' for internships. Use 'any' to return all types.

## `remoteOnly` (type: `boolean`):

When enabled, appends 'remote' to all search queries and marks all results as is\_remote: true. Enable this when the user asks specifically for remote, work-from-home, or WFH jobs.

## `proxyCountry` (type: `string`):

2-letter country code for residential proxy location (e.g. 'US', 'GB', 'CA'). Controls which Google region is scraped. Default: US. Change this to target job markets in other countries.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer New York"
  ],
  "startUrls": [],
  "maxResults": 10,
  "datePosted": "any",
  "employmentType": "any",
  "remoteOnly": false,
  "proxyCountry": "US"
}
```

# Actor output Schema

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

Array of job listing records. Key fields: job\_title (string), company\_name (string|null), location (string|null), is\_remote (boolean), employment\_type (string|null), salary\_range (string|null), salary\_min (number|null), salary\_max (number|null), salary\_period (YEAR|MONTH|WEEK|HOUR|null), date\_posted (string|null), job\_description (string|null), highlights (object with qualifications/responsibilities/benefits arrays|null), apply\_link (string|null), via\_platform (string|null), search\_query (string), source\_url (string), scraped\_at (ISO 8601 string).

# 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 = {
    "searchQueries": [
        "software engineer New York"
    ],
    "startUrls": [],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/google-jobs-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 = {
    "searchQueries": ["software engineer New York"],
    "startUrls": [],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/google-jobs-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 '{
  "searchQueries": [
    "software engineer New York"
  ],
  "startUrls": [],
  "maxResults": 10
}' |
apify call khadinakbar/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Jobs Scraper — Salary, Apply Links & MCP-Ready",
        "description": "Extract job listings from Google Jobs. Returns title, company, location, salary (parsed min/max), full description, apply link, employment type & more. Bulk queries supported. Export scraped data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "aNwooUpSlsjjOqbaZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~google-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-google-jobs-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/khadinakbar~google-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-google-jobs-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/khadinakbar~google-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-google-jobs-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",
                "properties": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Use this field when the user provides job titles, skills, or keyword phrases to search. Accepts multiple queries — the actor runs them all in one go. Example: [\"software engineer New York\", \"product manager remote\"]. Use startUrls instead when the user provides a direct Google Jobs URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Use this field when the user provides a specific Google Jobs URL (e.g. https://www.google.com/search?q=nurse&ibp=htl;jobs). Do NOT use this when the user describes a job role or keyword — use searchQueries instead.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum total number of job listings to extract across all queries. Must be between 1 and 500. Default: 50. Each result costs $0.003 — so 100 results costs $0.30.",
                        "default": 50
                    },
                    "datePosted": {
                        "title": "Date Posted Filter",
                        "enum": [
                            "any",
                            "today",
                            "3days",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Filter jobs by how recently they were posted. 'any' returns all results. 'today' returns jobs posted in the last 24 hours. 'week' returns jobs from the past 7 days.",
                        "default": "any"
                    },
                    "employmentType": {
                        "title": "Employment Type",
                        "enum": [
                            "any",
                            "FULLTIME",
                            "PARTTIME",
                            "CONTRACTOR",
                            "INTERN"
                        ],
                        "type": "string",
                        "description": "Filter by job type. Use 'FULLTIME' for permanent full-time roles, 'PARTTIME' for part-time, 'CONTRACTOR' for contract/freelance work, 'INTERN' for internships. Use 'any' to return all types.",
                        "default": "any"
                    },
                    "remoteOnly": {
                        "title": "Remote Jobs Only",
                        "type": "boolean",
                        "description": "When enabled, appends 'remote' to all search queries and marks all results as is_remote: true. Enable this when the user asks specifically for remote, work-from-home, or WFH jobs.",
                        "default": false
                    },
                    "proxyCountry": {
                        "title": "Proxy Country",
                        "type": "string",
                        "description": "2-letter country code for residential proxy location (e.g. 'US', 'GB', 'CA'). Controls which Google region is scraped. Default: US. Change this to target job markets in other countries.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```