# JobHunt AI — Multi-Board Job Search & AI Matching (`eternallabs/jobhunt-ai`) Actor

Scrape jobs from LinkedIn, Indeed, Glassdoor, ZipRecruiter and Google Jobs in one run. Search multiple roles and locations simultaneously. Score every job against your resume using Claude AI — get a 0–100 match score, verdict, and missing skills.

- **URL**: https://apify.com/eternallabs/jobhunt-ai.md
- **Developed by:** [Jona](https://apify.com/eternallabs) (community)
- **Categories:** Jobs, AI, Developer tools
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

### What does JobHunt AI do?

**JobHunt AI scrapes job listings from multiple search terms and locations in one Apify Actor** and returns clean, deduplicated JSON ready for analysis, export, automation, or direct API use. Primary boards: [Indeed](https://www.indeed.com/) and [LinkedIn Jobs](https://www.linkedin.com/jobs/). Optional boards: [Google Jobs](https://www.google.com/search?q=jobs), [ZipRecruiter](https://www.ziprecruiter.com/), and [Glassdoor](https://www.glassdoor.com/Job/) when available. It can also score each job against your resume or skills using Claude AI.

Run it by entering a role, location, freshness window, and selected boards in the Apify Input tab. Because it runs on Apify, you also get API access, scheduling, integrations, proxy support where applicable, monitoring, dataset exports, and cloud execution without maintaining servers.

### Why use JobHunt AI?

Most job scrapers focus on one board and return raw rows. JobHunt AI is built for job seekers, recruiters, talent researchers, and founders who need one consolidated job feed across primary job boards, with optional best-effort coverage for additional boards.

Use it to monitor fresh roles, compare job supply across locations, research hiring demand, build lead lists, or prioritize applications. The optional AI matching layer helps answer the practical question: which jobs are actually worth applying to? When enabled, each job gets a 0-100 fit score, a verdict, a short list of missing skills, and the top technical keywords from the job description.

### How to use JobHunt AI

1. Open the Actor on Apify and go to the Input tab.
2. Enter one fallback `search_term`, or use `search_terms` to search several roles in one run.
3. Set one fallback `location`, or use `locations` to search several markets in one run.
4. Choose how fresh results should be with `hours_old`.
5. Select the boards to scrape. Indeed and LinkedIn are the primary boards; Google Jobs, ZipRecruiter, and Glassdoor are optional and may return fewer results or be blocked depending on query/location.
6. Optionally enable AI scoring and provide your Anthropic API key plus resume or skills text.
7. Run the Actor and open the Dataset tab to view or export results.

For local development, run:

```bash
apify run --input '{"search_terms":["AI engineer","ML engineer","LLM engineer"],"locations":["Remote","San Francisco","New York"],"boards":["indeed","linkedin"],"hours_old":24,"results_wanted":10}'
````

### Input

Configure the Actor from the Apify Input tab or send JSON through the API.

```json
{
  "search_term": "AI engineer",
  "search_terms": ["AI engineer", "ML engineer", "LLM engineer"],
  "location": "Remote",
  "locations": ["Remote", "San Francisco", "New York"],
  "hours_old": 72,
  "results_wanted": 50,
  "boards": ["indeed", "linkedin"],
  "enable_ai_scoring": false,
  "resume_text": "",
  "anthropic_api_key": "",
  "min_ai_score": 0,
  "country_indeed": "USA"
}
```

Provide either `search_terms` or `search_term`. Provide either `locations` or `location`. When list fields are provided, the Actor searches every search term and location combination, then deduplicates jobs across the full combined result set. Primary boards are Indeed and LinkedIn. Optional boards are Google Jobs, ZipRecruiter, and Glassdoor. Some boards may return zero results due to upstream blocking or availability. AI scoring is optional and uses your own Anthropic API key. `min_ai_score` only applies when AI scoring is enabled.

### Output

The Actor pushes one JSON object per job to the default Apify dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
[
  {
    "id": "example-123",
    "title": "Senior AI Engineer",
    "company": "Example Labs",
    "location": "Remote",
    "job_type": "fulltime",
    "date_posted": "2026-06-03",
    "salary_min": 150000,
    "salary_max": 210000,
    "salary_currency": "USD",
    "description": "Build production LLM systems and evaluate model quality...",
    "job_url": "https://example.com/jobs/senior-ai-engineer",
    "source": "indeed",
    "is_remote": true,
    "ai_score": 86,
    "ai_verdict": "apply_now",
    "ai_missing_skills": ["Kubernetes"],
    "keywords": ["Python", "LLMs", "RAG", "evaluation", "Kubernetes"]
  }
]
```

### Data table

| Field | Description |
| --- | --- |
| `id` | JobSpy-provided job identifier when available |
| `title` | Job title |
| `company` | Hiring company |
| `location` | Job location |
| `job_type` | Job type when provided by the board |
| `date_posted` | Posted date returned by the source |
| `salary_min` | Minimum salary when available |
| `salary_max` | Maximum salary when available |
| `salary_currency` | Salary currency when available |
| `description` | Job description capped at 3,000 characters |
| `job_url` | Direct job listing URL |
| `source` | Board that returned the job |
| `is_remote` | Whether the job is marked remote |
| `ai_score` | Claude resume-match score from 0 to 100, or null |
| `ai_verdict` | `apply_now`, `consider`, `skip`, `error`, or null |
| `ai_missing_skills` | Skills Claude identified as gaps, or null |
| `keywords` | Top technical skills and keywords extracted by Claude when AI scoring is enabled, or null |

### Pricing / Cost estimation

How much does it cost to scrape job boards with JobHunt AI? Actor pricing should be configured as pay-per-event, with one event per job result pushed to the dataset. A competitive starting point is $0.50 per 1,000 job results, with a free monthly allowance for trial users if enabled in Apify Console.

AI scoring uses your own Anthropic API key. A typical Claude scoring call for one job is roughly $0.001 to $0.003 depending on text length and Anthropic pricing. When AI scoring is enabled, JobHunt AI also makes a second small Claude call for keyword extraction on jobs that pass your score filter. Disable AI scoring when you only need raw job listings.

### Tips or Advanced options

Use the default Indeed and LinkedIn selection for the most stable V1 runs. Add Google Jobs, ZipRecruiter, or Glassdoor only when you want broader best-effort coverage and can tolerate zero-result boards. Use fewer boards, fewer search/location combinations, and lower `results_wanted` values for faster runs. Use `hours_old` to keep output focused on fresh jobs and reduce duplicate or stale listings. For best AI scoring, paste a concise resume or skills summary with core technologies, seniority, domain experience, and location preferences.

If you only want highly relevant jobs, enable AI scoring and set `min_ai_score` to 70 or 80. For broad market research, keep AI scoring disabled and export all results to CSV or Excel.

### FAQ, disclaimers, and support

Is scraping job boards legal? Public web data can often be collected, but you are responsible for using this Actor in compliance with each website's Terms of Service, robots.txt guidance, applicable laws, and Apify policies. Do not collect or store sensitive personal data unless you have a lawful basis and explicit permission.

Why are some boards missing results? Job boards change markup, rate limits, availability, and anti-bot behavior. Some boards may return zero results due to upstream blocking or availability. JobHunt AI handles per-board failures by continuing with the remaining boards, but individual sources may temporarily return fewer results.

Does this include Upwork, Fiverr, Freelancer, Toptal, Wellfound, RemoteOK, or WeWorkRemotely? Not in V1. Those boards require custom scrapers beyond JobSpy support and should be added only if user demand justifies the maintenance cost.

For bugs, feature requests, or custom job board integrations, use the Issues tab on Apify. Custom solutions are available for teams that need additional boards, scheduled alerting, or downstream workflow integrations.

# Actor input Schema

## `search_term` (type: `string`):

Fallback single job title, keyword, or role to search for when search\_terms is empty.

## `search_terms` (type: `array`):

Optional list of job titles, keywords, or roles. When provided, these override search\_term.

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

Fallback single location when locations is empty.

## `locations` (type: `array`):

Optional list of locations. When provided, these override location.

## `hours_old` (type: `integer`):

Only return jobs posted in the last N hours.

## `results_wanted` (type: `integer`):

Maximum number of jobs to request from each selected board.

## `max_results_total` (type: `integer`):

Maximum number of unique jobs returned after deduplication.

## `boards` (type: `array`):

Select which job boards to scrape. Primary boards: Indeed and LinkedIn. Google, ZipRecruiter, and Glassdoor may return fewer results or be blocked depending on query/location.

## `enable_ai_scoring` (type: `boolean`):

Score each job against your resume or skills using Claude AI.

## `resume_text` (type: `string`):

Paste your resume or a concise skills summary. Required only when AI scoring is enabled.

## `anthropic_api_key` (type: `string`):

Your Anthropic API key. Required only when AI scoring is enabled.

## `min_ai_score` (type: `integer`):

When AI scoring is enabled, only push jobs with this score or higher. Use 0 to disable filtering.

## `country_indeed` (type: `string`):

Country used by JobSpy for Indeed searches.

## Actor input object example

```json
{
  "search_term": "AI engineer",
  "search_terms": [
    "AI engineer",
    "ML engineer",
    "LLM engineer"
  ],
  "location": "Remote",
  "locations": [
    "Remote",
    "San Francisco",
    "New York"
  ],
  "hours_old": 72,
  "results_wanted": 50,
  "max_results_total": 500,
  "boards": [
    "indeed",
    "linkedin"
  ],
  "enable_ai_scoring": false,
  "resume_text": "",
  "min_ai_score": 0,
  "country_indeed": "USA"
}
```

# Actor output Schema

## `dataset` (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 = {
    "search_term": "AI engineer",
    "search_terms": [
        "AI engineer",
        "ML engineer",
        "LLM engineer"
    ],
    "location": "Remote",
    "locations": [
        "Remote",
        "San Francisco",
        "New York"
    ],
    "country_indeed": "USA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("eternallabs/jobhunt-ai").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 = {
    "search_term": "AI engineer",
    "search_terms": [
        "AI engineer",
        "ML engineer",
        "LLM engineer",
    ],
    "location": "Remote",
    "locations": [
        "Remote",
        "San Francisco",
        "New York",
    ],
    "country_indeed": "USA",
}

# Run the Actor and wait for it to finish
run = client.actor("eternallabs/jobhunt-ai").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 '{
  "search_term": "AI engineer",
  "search_terms": [
    "AI engineer",
    "ML engineer",
    "LLM engineer"
  ],
  "location": "Remote",
  "locations": [
    "Remote",
    "San Francisco",
    "New York"
  ],
  "country_indeed": "USA"
}' |
apify call eternallabs/jobhunt-ai --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "JobHunt AI — Multi-Board Job Search & AI Matching",
        "description": "Scrape jobs from LinkedIn, Indeed, Glassdoor, ZipRecruiter and Google Jobs in one run. Search multiple roles and locations simultaneously. Score every job against your resume using Claude AI — get a 0–100 match score, verdict, and missing skills.",
        "version": "0.1",
        "x-build-id": "hYNOSqnouHkbRFxm3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/eternallabs~jobhunt-ai/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-eternallabs-jobhunt-ai",
                "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/eternallabs~jobhunt-ai/runs": {
            "post": {
                "operationId": "runs-sync-eternallabs-jobhunt-ai",
                "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/eternallabs~jobhunt-ai/run-sync": {
            "post": {
                "operationId": "run-sync-eternallabs-jobhunt-ai",
                "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": {
                    "search_term": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Fallback single job title, keyword, or role to search for when search_terms is empty.",
                        "default": "AI engineer"
                    },
                    "search_terms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional list of job titles, keywords, or roles. When provided, these override search_term.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Fallback single location when locations is empty.",
                        "default": "Remote"
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional list of locations. When provided, these override location.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "hours_old": {
                        "title": "Posted within last N hours",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only return jobs posted in the last N hours.",
                        "default": 72
                    },
                    "results_wanted": {
                        "title": "Results wanted per board",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of jobs to request from each selected board.",
                        "default": 50
                    },
                    "max_results_total": {
                        "title": "Maximum Total Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique jobs returned after deduplication.",
                        "default": 500
                    },
                    "boards": {
                        "title": "Job boards",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select which job boards to scrape. Primary boards: Indeed and LinkedIn. Google, ZipRecruiter, and Glassdoor may return fewer results or be blocked depending on query/location.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "linkedin",
                                "indeed",
                                "glassdoor",
                                "zip_recruiter",
                                "google"
                            ],
                            "enumTitles": [
                                "LinkedIn Jobs",
                                "Indeed",
                                "Glassdoor",
                                "ZipRecruiter",
                                "Google Jobs"
                            ]
                        },
                        "default": [
                            "indeed",
                            "linkedin"
                        ]
                    },
                    "enable_ai_scoring": {
                        "title": "Enable AI scoring",
                        "type": "boolean",
                        "description": "Score each job against your resume or skills using Claude AI.",
                        "default": false
                    },
                    "resume_text": {
                        "title": "Resume or key skills",
                        "type": "string",
                        "description": "Paste your resume or a concise skills summary. Required only when AI scoring is enabled.",
                        "default": ""
                    },
                    "anthropic_api_key": {
                        "title": "Anthropic API key",
                        "type": "string",
                        "description": "Your Anthropic API key. Required only when AI scoring is enabled."
                    },
                    "min_ai_score": {
                        "title": "Minimum AI score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "When AI scoring is enabled, only push jobs with this score or higher. Use 0 to disable filtering.",
                        "default": 0
                    },
                    "country_indeed": {
                        "title": "Indeed country",
                        "type": "string",
                        "description": "Country used by JobSpy for Indeed searches.",
                        "default": "USA"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
