# Indeed Scraper (`scrapapi/indeed-scraper`) Actor

- **URL**: https://apify.com/scrapapi/indeed-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** AI, Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

## 💼 Indeed Scraper

A powerful Apify Actor that scrapes detailed job listings from Indeed with comprehensive data extraction, keyword search, URL-based scraping, and smart proxy fallback.

### ✨ Features

- ✅ **Keyword Search**: Search jobs by position/keywords and location
- ✅ **URL-Based Scraping**: Scrape from job URLs, company pages, or search URLs
- ✅ **Combined Mode**: Use both search and URLs together (each limited independently)
- ✅ **Multi-Country Support**: Support for 60+ countries with country-specific domains
- ✅ **Comprehensive Data**: Extract position, company, location, salary, job type, description, and more
- ✅ **Smart Proxy Fallback**: Automatic fallback (no proxy → datacenter → residential with 3 retries)
- ✅ **Duplicate Detection**: Filter out duplicate job listings
- ✅ **Company Details**: Extract company ratings and review counts (optional)
- ✅ **Apply Links**: Extract external application URLs (optional)
- ✅ **Real-time Logging**: Detailed progress logs with proxy events
- ✅ **Error Handling**: Robust error handling with automatic retries

### 📋 Input

#### JSON Example

```json
{
  "position": "web developer",
  "location": "San Francisco",
  "country": "United States",
  "maxItemsPerSearch": 100,
  "followApplyRedirects": false,
  "parseCompanyDetails": false,
  "saveOnlyUniqueItems": true,
  "startUrls": [
    { "url": "https://www.indeed.com/viewjob?jk=5916e62b577782e7" }
  ],
  "requestDelay": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input Fields

- **position** (optional): Positions/keywords for search (e.g., "web developer", "software engineer")
- **location** (optional): City, zip code or locality for search (e.g., "San Francisco", "New York, NY")
- **country** (optional, default: "United States"): Country for job search - supports 60+ countries
- **maxItemsPerSearch** (optional, default: 100): Maximum jobs per search/URL (each limited independently)
- **followApplyRedirects** (optional, default: false): Follow redirects to get final apply URLs
- **parseCompanyDetails** (optional, default: false): Extract company rating and reviews
- **saveOnlyUniqueItems** (optional, default: true): Filter duplicate job listings
- **startUrls** (optional): List of URLs to scrape (job URLs, company pages, search URLs)
- **requestDelay** (optional, default: 1): Delay between requests in seconds
- **proxyConfiguration** (optional): Proxy settings with automatic fallback

### 📊 Output

#### JSON Example

```json
{
  "id": "5916e62b577782e7",
  "positionName": "Product Engineer (Frontend)",
  "company": "Relace",
  "location": "San Francisco, CA",
  "salary": null,
  "jobType": ["Full-time"],
  "postedAt": "15 weeks ago",
  "url": "https://www.indeed.com/viewjob?jk=5916e62b577782e7",
  "externalApplyLink": "https://www.indeed.com/applystart?jk=...",
  "rating": null,
  "reviewsCount": 26,
  "description": "About Us Relace is building...",
  "descriptionHTML": "<div>...</div>",
  "scrapedAt": "2026-02-14T12:06:18.917318Z",
  "postingDateParsed": "2025-10-29T04:37:40.749Z",
  "searchInput": {
    "position": "web developer",
    "location": "San Francisco",
    "country": "United States"
  },
  "isExpired": false,
  "success": true
}
```

### 🔄 Proxy Strategy

1. **No Proxy** (default): Direct connection to Indeed
2. **Datacenter Proxy**: If configured or if no proxy is blocked
3. **Residential Proxy**: Automatic fallback if datacenter is blocked (with 3 retries)

All proxy events are logged clearly for monitoring.

### 🚀 How to Use

1. Go to https://console.apify.com
2. Find the actor "indeed-scraper" and click it
3. Configure inputs:
   - Enter position/keywords and location for search
   - OR add Start URLs
   - OR use both together
   - Select country
   - Configure other settings as needed
4. Click **Run**
5. Monitor logs and access results in **OUTPUT** tab

### 🌍 Supported Countries

The actor supports 60+ countries including:

- 🇺🇸 United States
- 🇬🇧 United Kingdom
- 🇨🇦 Canada
- 🇦🇺 Australia
- 🇩🇪 Germany
- 🇫🇷 France
- 🇯🇵 Japan
- 🇮🇳 India
- And 50+ more...

### ⚠️ Cautions

- Data collected from publicly available sources only
- User responsible for legal compliance
- Respect Indeed's terms of service
- Use appropriate delays between requests

### 💬 Support

For custom solutions or feature requests, contact us at dev.scraperengine@gmail.com

# Actor input Schema

## `position` (type: `string`):

💡 Any combination of positions or keywords for search.

✨ Can be used together with Start URLs - both will be scraped independently, each limited by Max job listings per search.

📝 Examples: 'web developer', 'software engineer', 'data scientist'

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

🎯 Maximum number of job listings to scrape for each keyword search and each Start URL.

💡 When both search and URLs are used together, each is limited independently by this value.

📈 Range: 1-10000
⚡ Default: 100 jobs

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

🌐 Select the country for job search.

📍 This determines which Indeed domain to use (e.g., United States → indeed.com, United Kingdom → uk.indeed.com)

💡 Default: United States

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

🏙️ Any combination of city, zip code or locality for search.

💡 Used together with position/keywords.

📝 Examples: 'San Francisco', 'New York, NY', '90210', 'Remote'

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

📊 If enabled, will also navigate to company page of each job posting to scrape company info not available directly on job posting page.

✨ Includes: Company rating and reviews count

⚡ Note: This may slow down scraping slightly

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

✨ If enabled, only unique job listings will be scraped.

🛡️ Prevents duplicate entries in your dataset.

💡 Recommended: Keep enabled for cleaner results

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

🔄 If enabled, will follow redirects of Indeed's externalApplyLink and output the final destination URL.

✨ Useful for getting direct application URLs.

⚡ Note: May add slight delay per job

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

📋 List of URLs that will be scraped.

✨ Supported URL types:
• Job detail URLs: https://www.indeed.com/viewjob?jk=...
• Company jobs URLs: https://www.indeed.com/cmp/Google/jobs
• Search/category URLs: https://www.indeed.com/jobs?q=...
• Main website URLs

💡 Can be combined with keyword search - both will execute independently.

## `requestDelay` (type: `integer`):

⏳ Delay between requests to avoid rate limiting.

📈 Range: 0-10 seconds
💡 Default: 1 second (recommended)

⚡ Tip: Lower values = faster scraping, Higher values = more reliable

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

🛡️ Configure proxy settings for enhanced reliability and bypassing restrictions.

🔄 Smart Fallback System:
1️⃣ No proxy (default) - Direct connection to Indeed
2️⃣ Datacenter proxy - If configured
3️⃣ Residential proxy - Automatic fallback if blocked (with 3 retries)

✅ The actor automatically switches to residential proxy if requests are blocked.

💡 Recommended: Enable proxy for better success rates!

## Actor input object example

```json
{
  "position": "web developer",
  "maxItemsPerSearch": 100,
  "country": "United States",
  "location": "San Francisco",
  "parseCompanyDetails": false,
  "saveOnlyUniqueItems": true,
  "followApplyRedirects": false,
  "startUrls": [
    "https://www.indeed.com/viewjob?jk=5916e62b577782e7"
  ],
  "requestDelay": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": "web developer",
    "location": "San Francisco",
    "startUrls": [
        "https://www.indeed.com/viewjob?jk=5916e62b577782e7"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/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": "web developer",
    "location": "San Francisco",
    "startUrls": ["https://www.indeed.com/viewjob?jk=5916e62b577782e7"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/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": "web developer",
  "location": "San Francisco",
  "startUrls": [
    "https://www.indeed.com/viewjob?jk=5916e62b577782e7"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/indeed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Scraper",
        "version": "0.1",
        "x-build-id": "y36ZIuFGDdTQF7LWh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~indeed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~indeed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~indeed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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": "string",
                        "description": "💡 Any combination of positions or keywords for search.\n\n✨ Can be used together with Start URLs - both will be scraped independently, each limited by Max job listings per search.\n\n📝 Examples: 'web developer', 'software engineer', 'data scientist'"
                    },
                    "maxItemsPerSearch": {
                        "title": "📊 Max Job Listings per Search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🎯 Maximum number of job listings to scrape for each keyword search and each Start URL.\n\n💡 When both search and URLs are used together, each is limited independently by this value.\n\n📈 Range: 1-10000\n⚡ Default: 100 jobs",
                        "default": 100
                    },
                    "country": {
                        "title": "🌍 Country for Search",
                        "enum": [
                            "Antarctica",
                            "Argentina",
                            "Australia",
                            "Austria",
                            "Bahrain",
                            "Belgium",
                            "Brazil",
                            "Canada",
                            "Chile",
                            "China",
                            "Colombia",
                            "Costa Rica",
                            "Czech Republic",
                            "Denmark",
                            "Ecuador",
                            "Egypt",
                            "Finland",
                            "France",
                            "Germany",
                            "Greece",
                            "Hong Kong",
                            "Hungary",
                            "India",
                            "Indonesia",
                            "Ireland",
                            "Israel",
                            "Italy",
                            "Japan",
                            "Kuwait",
                            "Luxembourg",
                            "Mexico",
                            "Morocco",
                            "Netherlands",
                            "New Zealand",
                            "Nigeria",
                            "Norway",
                            "Oman",
                            "Pakistan",
                            "Panama",
                            "Peru",
                            "Philippines",
                            "Poland",
                            "Portugal",
                            "Qatar",
                            "Romania",
                            "Saudi Arabia",
                            "Singapore",
                            "South Africa",
                            "South Korea",
                            "Spain",
                            "Sweden",
                            "Switzerland",
                            "Taiwan",
                            "Thailand",
                            "Turkey",
                            "Ukraine",
                            "United Arab Emirates",
                            "United Kingdom",
                            "United States",
                            "Uruguay",
                            "Venezuela",
                            "Vietnam"
                        ],
                        "type": "string",
                        "description": "🌐 Select the country for job search.\n\n📍 This determines which Indeed domain to use (e.g., United States → indeed.com, United Kingdom → uk.indeed.com)\n\n💡 Default: United States",
                        "default": "United States"
                    },
                    "location": {
                        "title": "📍 Location for Search",
                        "type": "string",
                        "description": "🏙️ Any combination of city, zip code or locality for search.\n\n💡 Used together with position/keywords.\n\n📝 Examples: 'San Francisco', 'New York, NY', '90210', 'Remote'"
                    },
                    "parseCompanyDetails": {
                        "title": "🏢 Scrape Company Details",
                        "type": "boolean",
                        "description": "📊 If enabled, will also navigate to company page of each job posting to scrape company info not available directly on job posting page.\n\n✨ Includes: Company rating and reviews count\n\n⚡ Note: This may slow down scraping slightly",
                        "default": false
                    },
                    "saveOnlyUniqueItems": {
                        "title": "🔍 Save Only Unique Job Listings",
                        "type": "boolean",
                        "description": "✨ If enabled, only unique job listings will be scraped.\n\n🛡️ Prevents duplicate entries in your dataset.\n\n💡 Recommended: Keep enabled for cleaner results",
                        "default": true
                    },
                    "followApplyRedirects": {
                        "title": "🔗 Follow Redirects for Apply Link",
                        "type": "boolean",
                        "description": "🔄 If enabled, will follow redirects of Indeed's externalApplyLink and output the final destination URL.\n\n✨ Useful for getting direct application URLs.\n\n⚡ Note: May add slight delay per job",
                        "default": false
                    },
                    "startUrls": {
                        "title": "🔗 Start URLs",
                        "type": "array",
                        "description": "📋 List of URLs that will be scraped.\n\n✨ Supported URL types:\n• Job detail URLs: https://www.indeed.com/viewjob?jk=...\n• Company jobs URLs: https://www.indeed.com/cmp/Google/jobs\n• Search/category URLs: https://www.indeed.com/jobs?q=...\n• Main website URLs\n\n💡 Can be combined with keyword search - both will execute independently.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "requestDelay": {
                        "title": "⏱️ Request Delay (seconds)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "⏳ Delay between requests to avoid rate limiting.\n\n📈 Range: 0-10 seconds\n💡 Default: 1 second (recommended)\n\n⚡ Tip: Lower values = faster scraping, Higher values = more reliable",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "🛡️ Configure proxy settings for enhanced reliability and bypassing restrictions.\n\n🔄 Smart Fallback System:\n1️⃣ No proxy (default) - Direct connection to Indeed\n2️⃣ Datacenter proxy - If configured\n3️⃣ Residential proxy - Automatic fallback if blocked (with 3 retries)\n\n✅ The actor automatically switches to residential proxy if requests are blocked.\n\n💡 Recommended: Enable proxy for better success rates!"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```