# 🚀 Google Jobs Scraper (`api-empire/google-jobs-scraper`) Actor

- **URL**: https://apify.com/api-empire/google-jobs-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 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.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

Scrape Google Jobs at scale — titles, companies, locations, descriptions, salaries, schedule types, posting dates, apply links, logos, and rich highlights — with a built-in smart proxy fallback that adapts to Google's block walls so you do not have to.

---

### 🌟 Why Choose Us?

- 🛡️ **Smart 3-tier proxy fallback** — starts direct, escalates to datacenter, then residential (3 retries). One block does not kill the run.
- 🌐 **Bulk URL support** — drop in many Google Jobs search URLs in a single run.
- 🧠 **Two ways to query** — paste search URLs or just supply keywords + location.
- 📦 **Rich payload** — full descriptions, qualifications, benefits, responsibilities, salary, schedule type, posted-at, multiple apply links, logos.
- 🔴 **Live streaming** — every job is pushed to the dataset the moment it is parsed. A crash mid-run still leaves you with the rows already scraped.
- 🌍 **Multi-language friendly** — date / salary / schedule detection works across English, Spanish, Portuguese, Indonesian, Italian, French, German and more.

---

### 🔑 Key Features

| Feature | Description |
| --- | --- |
| 🌐 Bulk URLs | Paste many Google Jobs URLs at once |
| 🔍 Keyword + Location mode | Skip URLs and just give us what to search for |
| 🏢 Company filter | Keep only jobs from a target company |
| 💼 Job type filter | Full-time, Part-time, Contractor, Internship |
| 📅 Date filter | Today, 3 days, week, month, or any |
| 📄 Pagination | Walk N pages of results per query |
| 🎁 Hard cap | Limit total rows pushed to the dataset |
| 🛡️ Proxy fallback | Auto-escalates on block |
| 📊 Two dataset views | Overview + Full Details, both with emoji column labels |

---

### 📥 Input

```json
{
  "startUrls": [
    { "url": "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs" }
  ],
  "includeKeyword": "software engineer, python",
  "locationName": "New York, NY",
  "countryName": "United States",
  "companyName": "",
  "jobType": "FULLTIME",
  "datePosted": "week",
  "pagesToFetch": 5,
  "maxItems": 100,
  "includeUnfilteredResults": false,
  "requestDelay": 1.5,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

**Field reference**

- **`startUrls`** — array of Google Jobs URLs. If empty, the actor builds one from the keyword + location fields.
- **`includeKeyword`** — comma-separated keywords used both to build the query and to filter results.
- **`locationName`** — focus location (city / region / country).
- **`countryName`** — country name used to set Google's `gl` parameter.
- **`companyName`** — keep only jobs whose company contains this substring.
- **`jobType`** — empty (any), `FULLTIME`, `PARTTIME`, `CONTRACTOR`, `INTERN`.
- **`datePosted`** — `all`, `today`, `3days`, `week`, `month`.
- **`pagesToFetch`** — pages of results to walk per URL (~10 jobs / page).
- **`maxItems`** — hard cap on total rows pushed.
- **`includeUnfilteredResults`** — if `true`, keep jobs missing a title or company.
- **`requestDelay`** — polite seconds between requests; random jitter added.
- **`proxyConfiguration`** — Apify proxy editor. Defaults to **no proxy** so the actor uses its own ladder.

***

### 📤 Output

Each pushed item:

```json
{
  "title": "Senior Android Engineer",
  "companyName": "1001",
  "location": "Erbil",
  "via": "Built In",
  "description": "Job Description: 1001 is seeking …",
  "jobHighlights": [
    { "title": "Qualifications",  "items": ["6+ years Android dev", "Strong Kotlin", "TDD experience"] },
    { "title": "Benefits",        "items": [] },
    { "title": "Responsibilities","items": ["Design and build features", "Code reviews", "Mentor juniors"] }
  ],
  "metadata": {
    "postedAt": "6 days ago",
    "scheduleType": "Full-time",
    "salary": ""
  },
  "extras": ["6 days ago", "Full-time"],
  "applyLink": [
    { "title": "Apply on Built In", "link": "https://builtin.com/job/…" }
  ],
  "logo": "https://encrypted-tbn0.gstatic.com/images?q=tbn:…",
  "_id": "7rxg7R41fZScxVBtAAAAAA=="
}
```

***

### 🚀 How to Use (Apify Console)

1. Log in at <https://console.apify.com> → **Actors**.
2. Open this actor (`google-jobs-scraper`).
3. Choose **either**:
   - Paste one or more Google Jobs URLs into **Google Jobs URLs**, **OR**
   - Fill in **Include keywords** + **Location** + **Country**.
4. Tweak **Job type**, **Date posted**, **Pages to fetch**, **Maximum results** as needed.
5. (Optional) Set **Proxy configuration** — by default the actor decides on its own.
6. Click **Start**.
7. Watch the **Logs** tab — each scraped job is announced in real time.
8. Open the **Storage → Dataset** tab to inspect the **Overview** and **Full Details** views.
9. Export to JSON / CSV / XLSX.

***

### 🤖 Use via API

```bash
curl -X POST "https://api.apify.com/v2/acts/<USER>~google-jobs-scraper/runs?token=$APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
       "startUrls": [{ "url": "https://www.google.com/search?q=React+Developer+jobs&ibp=htl;jobs" }],
       "maxItems": 100,
       "pagesToFetch": 5,
       "datePosted": "week"
     }'
```

***

### 🛡️ Smart proxy fallback

```
DIRECT  ─►  DATACENTER  ─►  RESIDENTIAL (×3 retries)
```

- The run starts **without a proxy**.
- On a Google block (HTTP 403/429/503, captcha page, "unusual traffic"), the actor switches to **DATACENTER**.
- If that also blocks, the actor switches to **RESIDENTIAL** and will try up to **3 times** with fresh residential sessions.
- Once a tier succeeds, the actor **locks** to that tier for the rest of the run.
- Every transition is logged with a 🛑/🔒/🌐 marker for full traceability.

If you set a custom proxy in **Proxy configuration**, that takes precedence — but if it fails, the actor still drops down to the fallback ladder.

***

### ⭐ Best Use Cases

- 📈 Job-market analytics and dashboards
- 🤝 Lead generation for recruitment agencies
- 🛠️ Building niche job-board aggregators
- 🧪 Competitive-intelligence around hiring signals
- 🤖 Feeding AI workflows that need fresh hiring data

***

### 💰 Pricing

**Pay-per-Result.** The actor uses Apify's synthetic `apify-default-dataset-item` event — you are charged per job row pushed to the default dataset. No charge for failed runs, no fixed monthly fee.

The Apify Store page shows the live per-item price.

***

### ❓ Frequently Asked Questions

**Q: Do I need a proxy?**
A: No. The actor tries direct first and only spins up paid proxies if Google blocks the direct request.

**Q: What if my custom proxy fails?**
A: The actor logs the failure and drops down to its own fallback ladder so the run keeps going.

**Q: Why are some jobs missing salary / posted date?**
A: Google does not always render those chips. The actor falls back to language-aware regex over the full card text, but if Google omits the data entirely there is nothing to recover.

**Q: How fresh are the results?**
A: As fresh as Google's Jobs vertical itself — usually within hours of being posted.

**Q: Can I scrape only a specific company?**
A: Yes — fill in **Filter by company**.

***

### 📬 Support & Feedback

Found a bug or want a new feature? Open an issue on the Actor's GitHub or message us via the Apify Console.

***

### ⚖️ Cautions / Legal

- Data is collected only from **publicly available Google Jobs search results**.
- You are responsible for compliance with GDPR, CCPA, anti-spam laws, and Google's Terms of Service.
- Respect target sites' rate limits and `robots.txt`.

# Actor input Schema

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

Paste one or more Google Jobs search URLs. You can mix multiple URLs to scrape several queries / locations in a single run. Leave empty if you prefer to build the query from the keyword + location fields below.

## `includeKeyword` (type: `string`):

Comma-separated keywords used to build a Google Jobs query (e.g. "software engineer, python"). Also used to filter results client-side. Ignored when 'Google Jobs URLs' is provided.

## `locationName` (type: `string`):

City, region or country name to focus the search on (e.g. "New York, NY", "London", "India").

## `countryName` (type: `string`):

Country used to set Google's geo (`gl`) parameter. Affects which regional results Google returns.

## `companyName` (type: `string`):

Optional. Only keep jobs whose company name contains this string (case-insensitive).

## `jobType` (type: `string`):

Filter results by employment type.

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

Filter results by how recently the job was posted.

## `pagesToFetch` (type: `integer`):

Optional. How many pages of results to walk per URL/query (each page returns ~10 jobs). Leave empty to auto-derive from Max results: ceil(maxItems / 10). When both are set, this value wins.

## `maxItems` (type: `integer`):

Hard cap on total job rows pushed to the dataset across all URLs/queries. Note: Google's `/async/callback:550` endpoint caps a single query at ~100 results (the `start>=100` ceiling), and many queries exhaust earlier. To reach larger totals, provide multiple URLs/queries (e.g. different locations or keyword variations) in the Source URLs list.

## `includeUnfilteredResults` (type: `boolean`):

If on, also push jobs missing a title or company. Off by default for cleaner output.

## `proxyConfiguration` (type: `object`):

Optional custom proxy URLs. The scraper always uses Apify RESIDENTIAL as the fallback (up to 3 retries). If you provide custom proxy URLs here, those are tried first (up to 3 retries) and then it falls back to RESIDENTIAL.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"
  ],
  "includeKeyword": "software engineer, python",
  "locationName": "New York, NY",
  "countryName": "United States",
  "jobType": "",
  "datePosted": "all",
  "maxItems": 10,
  "includeUnfilteredResults": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": [
        "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/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 = {
    "startUrls": ["https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/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 '{
  "startUrls": [
    "https://www.google.com/search?q=Software+Engineer+jobs&ibp=htl;jobs"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call api-empire/google-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🚀 Google Jobs Scraper",
        "description": null,
        "version": "0.1",
        "x-build-id": "tLsYeuRMdwcxgXQOt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~google-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-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/api-empire~google-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-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/api-empire~google-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-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": {
                    "startUrls": {
                        "title": "🌐 Google Jobs URLs (Bulk supported)",
                        "type": "array",
                        "description": "Paste one or more Google Jobs search URLs. You can mix multiple URLs to scrape several queries / locations in a single run. Leave empty if you prefer to build the query from the keyword + location fields below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeKeyword": {
                        "title": "🔍 Include keywords",
                        "type": "string",
                        "description": "Comma-separated keywords used to build a Google Jobs query (e.g. \"software engineer, python\"). Also used to filter results client-side. Ignored when 'Google Jobs URLs' is provided."
                    },
                    "locationName": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "City, region or country name to focus the search on (e.g. \"New York, NY\", \"London\", \"India\")."
                    },
                    "countryName": {
                        "title": "🌎 Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "New Zealand",
                            "Ireland",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Portugal",
                            "Netherlands",
                            "Belgium",
                            "Luxembourg",
                            "Switzerland",
                            "Austria",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Iceland",
                            "Poland",
                            "Czech Republic",
                            "Slovakia",
                            "Hungary",
                            "Romania",
                            "Bulgaria",
                            "Greece",
                            "Croatia",
                            "Slovenia",
                            "Serbia",
                            "Ukraine",
                            "Russia",
                            "Turkey",
                            "India",
                            "Pakistan",
                            "Bangladesh",
                            "Sri Lanka",
                            "Nepal",
                            "China",
                            "Hong Kong",
                            "Taiwan",
                            "Japan",
                            "South Korea",
                            "Singapore",
                            "Malaysia",
                            "Indonesia",
                            "Thailand",
                            "Vietnam",
                            "Philippines",
                            "United Arab Emirates",
                            "Saudi Arabia",
                            "Qatar",
                            "Kuwait",
                            "Bahrain",
                            "Oman",
                            "Israel",
                            "Jordan",
                            "Lebanon",
                            "Egypt",
                            "Iraq",
                            "Iran",
                            "South Africa",
                            "Nigeria",
                            "Kenya",
                            "Ghana",
                            "Morocco",
                            "Tunisia",
                            "Algeria",
                            "Ethiopia",
                            "Brazil",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "Venezuela",
                            "Uruguay",
                            "Costa Rica",
                            "Panama",
                            "Dominican Republic",
                            "Ecuador",
                            "Kazakhstan",
                            "Uzbekistan",
                            "Azerbaijan",
                            "Georgia",
                            "Armenia"
                        ],
                        "type": "string",
                        "description": "Country used to set Google's geo (`gl`) parameter. Affects which regional results Google returns.",
                        "default": "United States"
                    },
                    "companyName": {
                        "title": "🏢 Filter by company",
                        "type": "string",
                        "description": "Optional. Only keep jobs whose company name contains this string (case-insensitive)."
                    },
                    "jobType": {
                        "title": "💼 Job type",
                        "enum": [
                            "",
                            "FULLTIME",
                            "PARTTIME",
                            "CONTRACTOR",
                            "INTERN"
                        ],
                        "type": "string",
                        "description": "Filter results by employment type.",
                        "default": ""
                    },
                    "datePosted": {
                        "title": "📅 Date posted",
                        "enum": [
                            "all",
                            "today",
                            "3days",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Filter results by how recently the job was posted.",
                        "default": "all"
                    },
                    "pagesToFetch": {
                        "title": "📄 Pages to fetch (per query)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Optional. How many pages of results to walk per URL/query (each page returns ~10 jobs). Leave empty to auto-derive from Max results: ceil(maxItems / 10). When both are set, this value wins."
                    },
                    "maxItems": {
                        "title": "🎁 Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on total job rows pushed to the dataset across all URLs/queries. Note: Google's `/async/callback:550` endpoint caps a single query at ~100 results (the `start>=100` ceiling), and many queries exhaust earlier. To reach larger totals, provide multiple URLs/queries (e.g. different locations or keyword variations) in the Source URLs list.",
                        "default": 10
                    },
                    "includeUnfilteredResults": {
                        "title": "🧪 Include incomplete rows",
                        "type": "boolean",
                        "description": "If on, also push jobs missing a title or company. Off by default for cleaner output.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy configuration",
                        "type": "object",
                        "description": "Optional custom proxy URLs. The scraper always uses Apify RESIDENTIAL as the fallback (up to 3 retries). If you provide custom proxy URLs here, those are tried first (up to 3 retries) and then it falls back to RESIDENTIAL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```