# Indeed Jobs Scraper - Fast & Reliable (API-based) (`solidscrape/indeed-jobs-scraper`) Actor

Scrape Indeed job listings reliably via Indeed's mobile-app GraphQL backend (no Cloudflare-gated HTML). Get title, company, location, salary, remote flag, date posted, and apply URL. Filter by keyword, location, country, job type, remote, and date posted. Export JSON/CSV/Excel.

- **URL**: https://apify.com/solidscrape/indeed-jobs-scraper.md
- **Developed by:** [Shahryar](https://apify.com/solidscrape) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Indeed Jobs Scraper – Fast, Reliable Indeed Job Data (No API Key)

**Indeed Jobs Scraper** extracts **Indeed job listings** quickly and reliably by talking to Indeed's **mobile-app GraphQL backend** instead of the Cloudflare-gated `indeed.com` HTML site. Search by **job title / keyword** and **location**, then export clean, structured data: title, company, salary, remote flag, date posted, apply URL, and more. This Indeed scraper needs **no API key and no login**, and you can **export results to JSON, CSV, or Excel**.

Built for **recruiters, job boards, sourcers, market-research and data teams** who need dependable Indeed data without fighting bot walls — a drop-in **Indeed API** alternative powered by Apify.

### What it does

- 🔎 **Keyword search** – scrape Indeed by one or more job titles / keywords, each searched separately.
- 📍 **Location + radius** – search by city, state, ZIP, region, or "Remote", with an adjustable mile radius (0–100).
- 🧰 **Filters** – job type (full-time / part-time / contract / internship), remote-only, and date posted (last N days).
- 💵 **Salary** – min/max, currency, and pay period when Indeed provides it (real or estimated), plus a formatted `salaryText`.
- 🏢 **Company details** – name, company page URL, corporate website, logo, industry, and size label when Indeed exposes them.
- 🔗 **Apply URLs** – the canonical Indeed job URL plus the recruiter apply URL when available.
- 📤 **Export anywhere** – download as **JSON, CSV, or Excel**, or pull from the Apify dataset API.

### Why this scraper

Most Indeed scrapers hit `indeed.com` HTML, which sits behind Cloudflare and breaks constantly. This Actor instead uses the **same private GraphQL API that the Indeed iPhone app uses** (`apis.indeed.com/graphql`) with the app's static API key and iOS User-Agent — the approach popularized by the open-source [JobSpy](https://github.com/speedyapply/JobSpy) project. That backend returns **clean JSON**, so results are:

- ⚡ **Fast** – structured JSON, up to 100 jobs requested per page, cursor-paginated.
- 🛡️ **Reliable** – no HTML parsing, no CAPTCHAs, far fewer blocks than HTML scraping. The Actor rotates proxy sessions and backs off automatically on rate limits.
- 🧱 **Complete** – salary, company, location, remote flag, date posted, description, and apply URL in one record.
- 🌍 **Global** – choose the Indeed country site (US, UK, CA, DE, IN, AU, and 60+ more).
- 🔓 **No API key** – uses the key embedded in Indeed's mobile app; you only configure Apify Proxy.

> Pairs well with our other job and lead-gen scrapers (LinkedIn, Yelp, Google Maps, and more) to build complete recruiting and lead-generation pipelines.

### Example input

```json
{
  "searchQueries": ["software engineer", "product manager"],
  "location": "New York, NY",
  "country": "us",
  "radius": 25,
  "maxItems": 100,
  "datePosted": 7,
  "jobType": "fulltime",
  "remoteOnly": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

> Note: Indeed cannot combine `datePosted` with the `jobType` / `remoteOnly` filter. If you set both, `datePosted` is used and the job-type/remote filter is ignored for that run (the Actor logs a warning).

### Example output

Every item is pushed with `type: "job"`. Optional fields are set to `null` when Indeed does not expose them (the Actor never guesses values). A representative item:

```json
{
  "type": "job",
  "id": "in-1a2b3c4d5e6f7g8h",
  "title": "Senior Software Engineer",
  "company": "Acme Corp",
  "companyRating": null,
  "companyUrl": "https://www.indeed.com/cmp/Acme-Corp",
  "companyWebsite": "https://www.acme.com",
  "companyLogo": "https://d2q79iu7y748jz.cloudfront.net/s/_squareLogo/abc123.png",
  "companyIndustry": "Information Technology",
  "companySize": "1,000+ employees",
  "location": "New York, NY",
  "city": "New York",
  "state": "NY",
  "country": "US",
  "postalCode": "10001",
  "isRemote": false,
  "salary": {
    "min": 140000,
    "max": 180000,
    "currency": "USD",
    "period": "yearly",
    "isEstimated": false
  },
  "salaryText": "USD 140,000 - USD 180,000 / year",
  "jobType": ["fulltime"],
  "source": "Indeed",
  "datePosted": "2026-06-22T00:00:00.000Z",
  "description": "We are hiring a Senior Software Engineer to ...",
  "url": "https://www.indeed.com/viewjob?jk=1a2b3c4d5e6f7g8h",
  "applyUrl": "https://www.indeed.com/viewjob?jk=1a2b3c4d5e6f7g8h",
  "scrapedAt": "2026-06-26T12:00:00.000Z"
}
```

### Output fields

Every record uses `type: "job"`. Fields marked "if available" come straight from Indeed and are `null` when Indeed does not provide them for a listing.

| Field | Type | Description |
|---|---|---|
| `type` | string | Always `"job"` (item type discriminator). |
| `id` | string | Stable job ID in the form `in-<indeedJobKey>`. |
| `title` | string | null | Job title. |
| `company` | string | null | Employer / company name. |
| `companyRating` | number | null | Employer star rating. This query does not request a rating field from Indeed, so this is currently always `null` (the field is reserved for forward compatibility). |
| `companyUrl` | string | null | Indeed company page URL (if available). |
| `companyWebsite` | string | null | Employer's corporate website (if available). |
| `companyLogo` | string | null | Square company logo URL (if available). |
| `companyIndustry` | string | null | Employer industry, cleaned (if available). |
| `companySize` | string | null | Employer size label, e.g. `"1,000+ employees"` (if available). |
| `location` | string | null | Human-readable location string. |
| `city` | string | null | Parsed city. |
| `state` | string | null | Parsed state / admin region code. |
| `country` | string | null | Parsed country code (e.g. `"US"`). |
| `postalCode` | string | null | Parsed postal / ZIP code. |
| `isRemote` | boolean | `true` if the job is detected as remote (via Indeed attributes, location, or description keywords). |
| `salary` | object | null | `{ min, max, currency, period, isEstimated }` or `null` when no pay data is present. |
| `salaryText` | string | null | Formatted salary string for quick reading, or `null`. |
| `jobType` | array | null | Array of normalized types (e.g. `["fulltime"]`) or `null` when none are tagged. |
| `source` | string | null | Original source / board the listing came from (if available). |
| `datePosted` | string | null | ISO 8601 date the job was published, or `null`. |
| `description` | string | null | Clean plain-text job description (HTML stripped), or `null`. |
| `url` | string | Canonical Indeed job URL. |
| `applyUrl` | string | Recruiter apply URL when present, otherwise the Indeed job URL. |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was scraped. |

The `salary` object, when present, contains: `min` (number | null), `max` (number | null), `currency` (string | null), `period` (one of `hourly`, `daily`, `weekly`, `monthly`, `yearly`, or the raw Indeed value), and `isEstimated` (boolean — `true` when the figure is an Indeed estimate rather than employer-posted).

### Input reference

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchQueries` | array | Yes | `["software engineer"]` | Job titles / keywords to search. Each query is searched separately. At least one non-empty value is required. |
| `location` | string | No | `""` | City, state, ZIP, region, or "Remote". Empty = whole country. |
| `country` | string | No | `"us"` | Indeed country code/name (`us`, `uk`, `ca`, `de`, `in`, `au`, …). Controls the regional site and currency. |
| `radius` | integer | No | `25` | Miles around the location (0–100). Only used when a location is set. |
| `maxItems` | integer | No | `100` | Max jobs in total across all queries. `0` = no limit. |
| `datePosted` | integer | No | – | Only jobs posted within the last N days (1–60). Applied as an hours filter (days × 24). Optional. |
| `jobType` | string | No | `""` | One of `fulltime`, `parttime`, `contract`, `internship`, or empty for any. |
| `remoteOnly` | boolean | No | `false` | Only return jobs Indeed tags as remote. |
| `proxyConfiguration` | object | No | Apify Proxy on | Apify Proxy settings. The default Apify proxy is recommended. |

### Common use cases

- **Recruiting & sourcing** – pull fresh openings for a role and location every day.
- **Job-board aggregation** – feed an internal board or alerting system with structured Indeed data.
- **Salary & market research** – analyze pay ranges by title, location, and company.
- **Competitive hiring intelligence** – track which companies are hiring for what.
- **Lead generation** – build lists of companies actively hiring in a niche, then enrich with company website and size fields.

### FAQ

**Do I need an API key or login to scrape Indeed?** No. This Indeed scraper uses the API key embedded in the Indeed mobile app (the same one JobSpy uses), so there is **no API key** for you to obtain and no login. You only configure Apify Proxy.

**How does it avoid Cloudflare blocks?** It does not scrape `indeed.com` HTML. It calls Indeed's mobile-app GraphQL endpoint (`apis.indeed.com/graphql`) with the app's static API key and an iPhone User-Agent, which returns structured JSON and is far more tolerant of automation than the HTML site.

**Is this an Indeed API?** It is an **Indeed API alternative**: the Actor speaks to Indeed's own private mobile GraphQL API and returns clean JSON, giving you API-like structured data without an official Indeed API or API key.

**What formats can I export?** Results land in an Apify dataset, so you can **export to JSON, CSV, or Excel** (plus XML, RSS, or HTML) from the Console, or fetch them via the Apify API.

**Why are some `salary` or company fields `null`?** Indeed does not attach salary or full company details to every listing. When data isn't present, the field is `null` rather than guessed. Note that `companyRating` is not part of this query at all, so it is currently always `null` (it is kept in the schema for forward compatibility).

**How many jobs can I get and how is paging handled?** The Actor requests up to 100 jobs per page and follows Indeed's cursor pagination automatically until your `maxItems` cap is hit or the results run out. Set `maxItems: 0` for no limit.

**Which countries are supported?** US, UK, Canada, Germany, India, Australia, France, Spain, Italy, Netherlands, Ireland, Singapore, Mexico, Brazil, and 60+ more — set `country` to the two-letter code.

**Can I filter by date AND job type?** No — Indeed's backend doesn't allow both at once. If you set both, `datePosted` wins and the job-type/remote filter is skipped for that run (a warning is logged).

**What if it stops returning results?** Indeed occasionally rotates the mobile API key or rate-limits an IP. The Actor backs off, rotates the proxy session on `429`, and logs a clear, actionable error on repeated `401/403` (which would indicate the embedded key needs updating).

### Disclaimer

This Actor collects publicly available job-listing data. You are responsible for how you use the scraped data and for complying with Indeed's terms, applicable laws, and data-protection regulations.

# Actor input Schema

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

Job titles or keywords to search on Indeed, e.g. "software engineer", "registered nurse", "data analyst". Each query is searched separately.

## `location` (type: `string`):

City, state, ZIP, or region to search in, e.g. "New York, NY", "Remote", "London". Leave empty to search the whole country.

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

Indeed country to search. Two-letter code or name (e.g. "us", "uk", "ca", "de", "in", "au"). Controls the Indeed regional site and currency.

## `radius` (type: `integer`):

Distance in miles around the location to include. Only used when a location is set.

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

Maximum number of jobs to return in total (across all queries). Set 0 for no limit.

## `datePosted` (type: `integer`):

Only return jobs posted within the last N days, e.g. 1, 3, 7, 14. Leave empty for any date. Note: Indeed applies this as an hours filter (days x 24) and it cannot be combined with the job-type/remote filter below — if both are set, date posted wins.

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

Restrict to a single employment type.

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

If enabled, only return jobs Indeed tags as remote. Cannot be combined with the 'Date posted' filter (date posted takes priority if both are set).

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

Indeed's mobile GraphQL endpoint is far more tolerant than its HTML site, but routing through Apify Proxy spreads requests across IPs and improves reliability. The default Apify proxy is recommended.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer",
    "product manager"
  ],
  "location": "San Francisco, CA",
  "country": "us",
  "radius": 25,
  "maxItems": 100,
  "datePosted": 7,
  "jobType": "fulltime",
  "remoteOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

# 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"
    ],
    "location": "New York, NY",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidscrape/indeed-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"],
    "location": "New York, NY",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solidscrape/indeed-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"
  ],
  "location": "New York, NY",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solidscrape/indeed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Scraper - Fast & Reliable (API-based)",
        "description": "Scrape Indeed job listings reliably via Indeed's mobile-app GraphQL backend (no Cloudflare-gated HTML). Get title, company, location, salary, remote flag, date posted, and apply URL. Filter by keyword, location, country, job type, remote, and date posted. Export JSON/CSV/Excel.",
        "version": "0.1",
        "x-build-id": "HCoLLc7kHLaZPRvit"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidscrape~indeed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidscrape-indeed-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/solidscrape~indeed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidscrape-indeed-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/solidscrape~indeed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidscrape-indeed-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 (job titles / keywords)",
                        "type": "array",
                        "description": "Job titles or keywords to search on Indeed, e.g. \"software engineer\", \"registered nurse\", \"data analyst\". Each query is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, ZIP, or region to search in, e.g. \"New York, NY\", \"Remote\", \"London\". Leave empty to search the whole country."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Indeed country to search. Two-letter code or name (e.g. \"us\", \"uk\", \"ca\", \"de\", \"in\", \"au\"). Controls the Indeed regional site and currency.",
                        "default": "us"
                    },
                    "radius": {
                        "title": "Search radius (miles)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Distance in miles around the location to include. Only used when a location is set.",
                        "default": 25
                    },
                    "maxItems": {
                        "title": "Max jobs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of jobs to return in total (across all queries). Set 0 for no limit."
                    },
                    "datePosted": {
                        "title": "Date posted (max age in days)",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Only return jobs posted within the last N days, e.g. 1, 3, 7, 14. Leave empty for any date. Note: Indeed applies this as an hours filter (days x 24) and it cannot be combined with the job-type/remote filter below — if both are set, date posted wins."
                    },
                    "jobType": {
                        "title": "Job type",
                        "enum": [
                            "",
                            "fulltime",
                            "parttime",
                            "contract",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Restrict to a single employment type.",
                        "default": ""
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "If enabled, only return jobs Indeed tags as remote. Cannot be combined with the 'Date posted' filter (date posted takes priority if both are set).",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Indeed's mobile GraphQL endpoint is far more tolerant than its HTML site, but routing through Apify Proxy spreads requests across IPs and improves reliability. The default Apify proxy is recommended.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
