# Indeed Scraper — Jobs, Salaries, Companies & Full Descriptions (`rp_openpro.ai/indeed-scraper`) Actor

Scrape Indeed job listings from keyword search, location, and start URLs. Extract title, salary, company, location, ratings, full description, apply links, and optional company details. Fast HTTP scraping with embedded JSON parsing.

- **URL**: https://apify.com/rp\_openpro.ai/indeed-scraper.md
- **Developed by:** [Rémi Pelloux](https://apify.com/rp_openpro.ai) (community)
- **Categories:** AI, Agents, Developer tools
- **Stats:** 3 total users, 2 monthly users, 90.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Indeed Scraper — Jobs, Salaries, Companies & Full Descriptions

**The fastest Indeed scraper on Apify.** Extract job titles, salaries, companies, locations, ratings, full descriptions, apply links, and optional company profiles from Indeed search, keyword + location queries, and start URLs — across **50+ countries**.

**From $2.00 / 1,000 job listings** — cheaper than alternatives charging $3–$6. **10 free listings** per run to test.

> No official Indeed job-search API exists anymore. This actor scrapes public Indeed pages using embedded JSON (not fragile CSS selectors) for stable, structured output.

---

### Why this scraper is better

| Feature | misceres/indeed-scraper | **This actor** |
|---|---|---|
| Price per 1,000 | $3.00–$6.00 | **$2.00** |
| Full job description | ✅ | ✅ HTML + plain text |
| Company details | Optional | ✅ Optional + richer fields |
| Keyword + location search | ✅ | ✅ |
| Start URLs + company jobs URLs | ✅ | ✅ |
| Multi-country (50+) | ✅ | ✅ |
| Apply link redirect resolution | Optional | ✅ Optional |
| Unique job deduplication | ✅ | ✅ |
| HTTP-first (fast, low cost) | Browser-heavy | ✅ Embedded JSON parsing |
| Extra fields | Basic | ✅ sponsored, remote, benefits, urgentlyHiring |

---

### What data you get

Each job listing includes:

| Field | Description |
|---|---|
| `positionName` | Job title |
| `salary` | Salary as shown on Indeed |
| `jobType` | Full-time, Part-time, Contract, etc. |
| `company` | Hiring company name |
| `companyIndeedUrl` | Company page on Indeed |
| `location` | Job location |
| `rating` | Company rating (0–5) |
| `reviewsCount` | Number of company reviews |
| `externalApplyLink` | Employer apply URL (optional redirect follow) |
| `url` | Indeed job listing URL |
| `id` | Indeed job key (unique ID) |
| `postedAt` | Relative posting age ("3 days ago") |
| `postingDateParsed` | ISO 8601 parsed date when available |
| `description` | Full plain-text description |
| `descriptionHTML` | Full HTML description |
| `companyInfo` | Company profile when `parseCompanyDetails: true` |
| `searchInput` | Search params used to find this job |
| `urlInput` | Start URL if applicable |
| `sponsored` | Sponsored listing flag |
| `remoteWorkModel` | Remote / hybrid / on-site when available |
| `benefits` | Benefits list from job page |
| `urgentlyHiring` | Urgent hiring badge |
| `isExpired` | Whether listing expired |
| `scrapedAt` | ISO timestamp |

---

### Input

| Parameter | Default | Description |
|---|---|---|
| `position` | — | Keywords / job titles (array) |
| `location` | — | City, zip, or region |
| `country` | `US` | ISO country code (US, FR, GB, DE, …) |
| `maxItemsPerSearch` | `100` | Max jobs per keyword or start URL |
| `startUrls` | — | Search, company jobs, or viewjob URLs |
| `scrapeFullDescription` | **`true`** | Fetch full job page (disable for fast listing-only) |
| `parseCompanyDetails` | `false` | Scrape company Indeed profile |
| `saveOnlyUniqueItems` | `true` | Dedupe by job ID |
| `followApplyRedirects` | `false` | Resolve final apply URL |
| `detailConcurrency` | `8` | Parallel detail fetches |
| `proxyConfiguration` | Apify Proxy | **Recommended** |

#### Example — full detail (recommended)

```json
{
  "position": ["software engineer", "data analyst"],
  "location": "New York",
  "country": "US",
  "maxItemsPerSearch": 50,
  "scrapeFullDescription": true,
  "parseCompanyDetails": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Example — company jobs URL

```json
{
  "startUrls": [
    { "url": "https://www.indeed.com/cmp/Google/jobs" }
  ],
  "maxItemsPerSearch": 100,
  "scrapeFullDescription": true
}
```

#### Example — fast listing-only

```json
{
  "position": ["web developer"],
  "location": "San Francisco",
  "country": "US",
  "maxItemsPerSearch": 100,
  "scrapeFullDescription": false
}
```

***

### Pricing

| Tier | Per 1,000 job listings |
|---|---:|
| **Standard** | **$2.00** |
| Free trial | 10 listings / run |

Billing event: **`job-listing`** — one charge per dataset row.

Enable Pay-per-event monetization in Apify Console with the `job-listing` custom event.

***

### Quick start

#### Apify Console

1. Click **Try for free** (lightweight QA demo: 5 listings)
2. Add keywords + location, or paste start URLs
3. Keep **Scrape full job description** enabled for complete output
4. Enable **Apify Proxy** → **Start**

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("rp_openpro.ai/indeed-scraper").call(run_input={
    "position": ["software engineer"],
    "location": "New York",
    "country": "US",
    "maxItemsPerSearch": 50,
    "scrapeFullDescription": True,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["positionName"], job["company"], job["salary"])
```

***

### Supported countries

US, GB, FR, DE, CA, AU, NL, BE, ES, IT, CH, AT, IE, PL, PT, SE, NO, DK, FI, MX, BR, AR, CL, CO, IN, SG, HK, JP, KR, AE, SA, ZA, NZ, PH, MY, TH, VN, ID, TR, UA, RO, CZ, HU, GR, IL, EG, NG, MA, PK, QA, KW, and more.

***

### Use cases

- **Job market research** — salary benchmarks by role and city
- **Recruitment automation** — aggregate openings for your ATS
- **Competitor hiring tracking** — monitor company job pages
- **Lead generation** — find companies actively hiring in your niche
- **Academic / labor economics** — structured hiring trend datasets

***

### How it works

1. **Search discovery** — fetches Indeed listing pages via HTTP + Apify Proxy
2. **JSON extraction** — parses embedded `mosaic-provider-jobcards` data (stable, not CSS selectors)
3. **Detail enrichment** — fetches each job's embedded JSON for full description, benefits, apply link
4. **Optional company scrape** — visits `/cmp/` pages for company profile data
5. **Dedup + output** — unique jobs pushed to dataset with pay-per-result billing

**Try for free** uses a lightweight prefill (5 jobs, full description) so Apify QA completes in under 5 minutes. Production runs default to **100 jobs per search** with full descriptions.

***

### FAQ

**Does this use the official Indeed API?**\
No. Indeed deprecated public job-search APIs. This scrapes public listing pages.

**Do I lose full descriptions?**\
No. `scrapeFullDescription` defaults to `true`. Only the Apify demo prefill is limited to 5 jobs for speed.

**Do I need a proxy?**\
Strongly recommended. Enable `useApifyProxy: true` in production.

**Can I scrape company job pages?**\
Yes — paste URLs like `https://www.indeed.com/cmp/Google/jobs` in `startUrls`.

***

### Responsible use

Scrape only data you are legally allowed to collect. Respect Indeed's Terms of Service and applicable employment/privacy laws.

***

*Built by [Leadsit.eu](https://www.leadsit.eu) — B2B data tools for modern teams.*

*Keywords: indeed scraper, scrape indeed jobs, indeed job API alternative, job listing scraper, recruitment data, salary scraper, indeed automation*

# Actor input Schema

## `position` (type: `array`):

Job titles or keywords to search. Can be combined with start URLs — each source is scraped independently up to maxItemsPerSearch.

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

City, region, zip code, or locality used with position keywords.

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

ISO 2-letter country code for the Indeed domain (US, FR, GB, DE, etc.).

## `maxItemsPerSearch` (type: `integer`):

Maximum jobs to scrape per keyword search and per start URL.

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

Indeed search URLs, company jobs URLs (e.g. https://www.indeed.com/cmp/Google/jobs), or viewjob links.

## `parseCompanyDetails` (type: `boolean`):

Visit each company's Indeed page for description, logo, size, and ratings.

## `saveOnlyUniqueItems` (type: `boolean`):

Deduplicate jobs by Indeed job ID across all searches and URLs.

## `followApplyRedirects` (type: `boolean`):

Resolve Indeed externalApplyLink to the final employer application URL.

## `scrapeFullDescription` (type: `boolean`):

Fetch each job page for complete description HTML/text, benefits, and apply link. Disable for faster listing-only runs.

## `detailConcurrency` (type: `integer`):

Parallel job detail page fetches.

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

Apify Proxy recommended for reliable Indeed scraping.

## Actor input object example

```json
{
  "position": [
    "web developer",
    "data analyst"
  ],
  "location": "San Francisco",
  "country": "US",
  "maxItemsPerSearch": 5,
  "startUrls": [
    {
      "url": "https://www.indeed.com/jobs?q=software+engineer&l=New+York"
    },
    {
      "url": "https://www.indeed.com/cmp/Google/jobs"
    }
  ],
  "parseCompanyDetails": false,
  "saveOnlyUniqueItems": true,
  "followApplyRedirects": false,
  "scrapeFullDescription": true,
  "detailConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset of Indeed job listing objects.

# 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 = {
    "position": [
        "software engineer"
    ],
    "location": "New York",
    "country": "US",
    "maxItemsPerSearch": 5,
    "startUrls": [],
    "parseCompanyDetails": false,
    "saveOnlyUniqueItems": true,
    "followApplyRedirects": false,
    "scrapeFullDescription": true,
    "detailConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rp_openpro.ai/indeed-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 = {
    "position": ["software engineer"],
    "location": "New York",
    "country": "US",
    "maxItemsPerSearch": 5,
    "startUrls": [],
    "parseCompanyDetails": False,
    "saveOnlyUniqueItems": True,
    "followApplyRedirects": False,
    "scrapeFullDescription": True,
    "detailConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rp_openpro.ai/indeed-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 '{
  "position": [
    "software engineer"
  ],
  "location": "New York",
  "country": "US",
  "maxItemsPerSearch": 5,
  "startUrls": [],
  "parseCompanyDetails": false,
  "saveOnlyUniqueItems": true,
  "followApplyRedirects": false,
  "scrapeFullDescription": true,
  "detailConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call rp_openpro.ai/indeed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Scraper — Jobs, Salaries, Companies & Full Descriptions",
        "description": "Scrape Indeed job listings from keyword search, location, and start URLs. Extract title, salary, company, location, ratings, full description, apply links, and optional company details. Fast HTTP scraping with embedded JSON parsing.",
        "version": "1.0",
        "x-build-id": "y6MHQ5SltqGfTlkYG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rp_openpro.ai~indeed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rp_openpro.ai-indeed-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/rp_openpro.ai~indeed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rp_openpro.ai-indeed-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/rp_openpro.ai~indeed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rp_openpro.ai-indeed-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": {
                    "position": {
                        "title": "Positions / keywords for search",
                        "type": "array",
                        "description": "Job titles or keywords to search. Can be combined with start URLs — each source is scraped independently up to maxItemsPerSearch.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location for search",
                        "type": "string",
                        "description": "City, region, zip code, or locality used with position keywords.",
                        "default": ""
                    },
                    "country": {
                        "title": "Country for search",
                        "type": "string",
                        "description": "ISO 2-letter country code for the Indeed domain (US, FR, GB, DE, etc.).",
                        "default": "US"
                    },
                    "maxItemsPerSearch": {
                        "title": "Max job listings per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to scrape per keyword search and per start URL.",
                        "default": 100
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Indeed search URLs, company jobs URLs (e.g. https://www.indeed.com/cmp/Google/jobs), or viewjob links."
                    },
                    "parseCompanyDetails": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "Visit each company's Indeed page for description, logo, size, and ratings.",
                        "default": false
                    },
                    "saveOnlyUniqueItems": {
                        "title": "Save only unique job listings",
                        "type": "boolean",
                        "description": "Deduplicate jobs by Indeed job ID across all searches and URLs.",
                        "default": true
                    },
                    "followApplyRedirects": {
                        "title": "Follow apply link redirects",
                        "type": "boolean",
                        "description": "Resolve Indeed externalApplyLink to the final employer application URL.",
                        "default": false
                    },
                    "scrapeFullDescription": {
                        "title": "Scrape full job description",
                        "type": "boolean",
                        "description": "Fetch each job page for complete description HTML/text, benefits, and apply link. Disable for faster listing-only runs.",
                        "default": true
                    },
                    "detailConcurrency": {
                        "title": "Job detail concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel job detail page fetches.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy recommended for reliable Indeed scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
