# Job Description Keyword Analyzer – Match Resume Score (`scrapepilot/job-description-keyword-analyzer-match-resume-score`) Actor

Paste your resume, add job URLs or text – get match score, top required keywords, matched & missing keywords. Tailor your CV for each application. Bulk processing, checkpoint/resume. $7.99/month unlimited.

- **URL**: https://apify.com/scrapepilot/job-description-keyword-analyzer-match-resume-score.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$7.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

---
## 📝 Job Description Keyword Analyzer – Resume Match Score, Keyword Extractor

**Match your resume against multiple job descriptions – get keyword‑based match score, matched keywords, and missing keywords to tailor your applications.**  
Upload your resume text, provide job listing URLs or paste job descriptions, and the actor analyzes keyword overlap, extracts top required skills, and suggests missing keywords to add. Perfect for job seekers, recruitment agencies, and career coaches.

---

### 💡 What is the Job Description Keyword Analyzer?

The **Job Description Keyword Analyzer** is a smart Apify actor that helps you optimize your resume for specific job postings. It works by:

1. **Taking your resume text** (paste or upload)
2. **Fetching job descriptions** from URLs or accepting direct text input
3. **Extracting key keywords** from each job description (cleaned of stop words, bigrams included)
4. **Comparing** your resume against those keywords
5. **Producing** a match score (0–100%), list of matched keywords, and list of missing keywords you should add to your resume

The actor handles:
- Multiple job URLs in parallel
- Direct text job descriptions (e.g., copied from a job board)
- Automatic checkpoint/resume (so you don’t lose progress)
- Concurrency control to avoid overwhelming servers

**Perfect for:** Job seekers who want to tailor their resume for each application, recruitment agencies comparing candidate resumes to job specs, career coaches helping clients optimize CVs, and HR professionals evaluating applicant fit.

---

### 🚀 Key Features

| Feature                     | Description |
|-----------------------------|-------------|
| **Resume vs. job description matching** | Calculates percentage of job’s required keywords found in your resume. |
| **Automatic keyword extraction** | Identifies top 25 most relevant keywords from each job description (including bigrams). |
| **Matched & missing keywords** | Shows exactly which keywords your resume contains and which you need to add. |
| **Batch processing** | Submit dozens of job URLs at once – process them in parallel. |
| **Direct text input** | Paste job descriptions directly if you don’t have URLs. |
| **Checkpoint & resume** | Saves progress after each job – if interrupted, continues without re-processing. |
| **Residential proxy ready** | Avoids blocking when fetching many job URLs (optional). |
| **Clean JSON output** | Each job result includes match score, top keywords, matched list, missing list, and preview. |
| **Flat monthly pricing** | $7.99/month – unlimited analysis runs. No per‑event fees. |

---

### 📥 Input Parameters

The actor accepts a JSON object with the following fields:

| Parameter            | Type                | Required | Default | Description |
|----------------------|---------------------|----------|---------|-------------|
| `resumeText`         | string              | **Yes**  | –       | Your resume content (plain text, can include line breaks). |
| `jobUrls`            | array of objects    | No*      | –       | List of job description URLs, each as `{"url": "https://..."}`. |
| `jobDescriptionsText`| array of strings    | No*      | –       | List of job descriptions pasted directly as text. |
| `maxConcurrency`     | integer             | No       | `10`    | Number of simultaneous HTTP requests (for URLs). |
| `proxyConfiguration` | object              | No       | –       | Apify proxy configuration (optional, for fetching URLs). |

> **Note:** You must provide at least one job source (URLs or text descriptions).

#### Example Input (URLs only)

```json
{
  "resumeText": "Experienced software engineer with 5 years in Python, Django, React, and PostgreSQL. Strong background in agile development and team leadership.",
  "jobUrls": [
    {"url": "https://example.com/job/123"},
    {"url": "https://example.com/job/456"}
  ],
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

#### Example Input (Mixed URLs + Direct Text)

```json
{
  "resumeText": "Marketing specialist with SEO, content creation, Google Analytics, and email campaign management.",
  "jobUrls": [{"url": "https://company.com/careers/marketing-manager"}],
  "jobDescriptionsText": [
    "We are looking for a Digital Marketing Manager with experience in PPC, SEO, and social media advertising...",
    "Marketing Coordinator role requiring strong writing skills and knowledge of HubSpot."
  ]
}
```

***

### 📤 Output Fields

For each job description (whether from URL or direct text), the actor pushes one dataset item with the following structure:

| Field                      | Type   | Description |
|----------------------------|--------|-------------|
| `item_id`                  | string | Unique SHA1 identifier for the job source (used for checkpoint). |
| `source`                   | string | Either the URL or `Direct Text Input N`. |
| `match_score_percentage`   | integer | Percentage of job keywords found in your resume (0–100). |
| `top_required_keywords`    | array  | Up to 20 most important keywords from the job description. |
| `matched_keywords_in_resume`| array | Keywords that are present in your resume. |
| `missing_keywords_to_add`  | array | Keywords from the job description that are **not** in your resume. |
| `job_description_preview`  | string | First 200 characters of the job description (truncated). |
| `error`                    | string | (Only if failed) Reason for failure. |

#### Example Output

```json
[
  {
    "item_id": "sha1:7b3c8f2a9e5d6b1a4f3c2e1d0b9a8c7d6e5f4a3b",
    "source": "https://example.com/job/123",
    "match_score_percentage": 78,
    "top_required_keywords": [
      "python",
      "django",
      "postgresql",
      "react",
      "agile development",
      "team leadership"
    ],
    "matched_keywords_in_resume": [
      "python",
      "django",
      "postgresql",
      "react",
      "agile",
      "leadership"
    ],
    "missing_keywords_to_add": [
      "rest apis",
      "docker",
      "ci/cd"
    ],
    "job_description_preview": "We are looking for a Senior Python Developer with expertise in Django and REST APIs. Experience with containerization (Docker) and CI/CD pipelines is a plus..."
  }
]
```

If fetching a URL fails:

```json
{
  "item_id": "sha1:...",
  "source": "https://example.com/job/notfound",
  "error": "Failed to fetch or extract content"
}
```

***

### 💰 Pricing

| Plan                 | Price          | Description |
|----------------------|----------------|-------------|
| **Monthly Subscription** | **$7.99** | Unlimited analysis runs – no per‑job fees, no hidden costs. |

- **Flat monthly price** – you can run the actor as many times as you want, with any number of job descriptions.
- **No per‑result charges** – unlike pay‑per‑event actors, this is a fixed cost per month.
- **Free trial** – Apify provides $5 free monthly credit for new users; you can test this actor with that.

***

### 🛠 How to Use on Apify

1. **Create a task** with this actor.
2. **Paste your resume** into the `resumeText` field (plain text).
3. **Add job URLs** (as JSON array) or **paste job descriptions** directly.
4. **Optionally set concurrency** (default 10) and enable residential proxy if you expect many URL fetches.
5. **Run** – the actor will fetch each job description (or use direct text), compute match scores, and push results to the Dataset.
6. **Export** – download results as JSON, CSV, or Excel.

#### Running via API

```bash
curl -X POST "https://api.apify.com/v2/acts/your-username~job-description-keyword-analyzer/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "resumeText": "Your resume text here...",
    "jobUrls": [{"url": "https://example.com/job/1"}, {"url": "https://example.com/job/2"}]
  }'
```

***

### 🎯 Use Cases

| Use Case | How It Helps |
|----------|---------------|
| **Job seekers** | Tailor your resume to each job by seeing exactly which keywords are missing. |
| **Recruitment agencies** | Quickly compare candidate resumes against multiple job specs – identify best matches. |
| **Career coaches** | Provide data‑driven feedback to clients on how to improve their CVs for specific roles. |
| **HR / Talent acquisition** | Automate initial screening by checking keyword coverage. |
| **Students / graduates** | Understand industry requirements and adapt your CV accordingly. |

***

### ❓ Frequently Asked Questions

**1. What format does the resume need to be in?**\
Plain text. You can copy from your CV file (Word, PDF, Google Docs) and paste – the actor will clean it automatically. HTML tags are stripped.

**2. How is the match score calculated?**\
The actor extracts keywords from the job description (removing common stop words, adding bigrams). Then it checks which of those keywords appear in your resume text. The score is `(matched keywords / total job keywords) * 100`. Higher score means your resume covers more of the job’s requirements.

**3. What are “bigrams”?**\
Bigrams are two‑word phrases (e.g., “agile development”, “team leadership”). The actor includes them to capture multi‑word concepts like “machine learning” or “customer relationship management”.

**4. Can I use this for multiple resumes?**\
Yes, you can run the actor multiple times with different `resumeText` values. Each run costs nothing extra under the $7.99/month plan.

**5. Do I need proxies for fetching job URLs?**\
Not always. If you are processing a small number of URLs (e.g., <50) from well‑known job boards (LinkedIn, Indeed), datacenter IPs may work. For large batches or if you encounter blocks, enable residential proxies.

**6. What happens if a job URL is inaccessible (404, blocked)?**\
The actor logs an error and returns an item with the `error` field. It continues processing the remaining URLs. You are not charged extra for failed items (since pricing is monthly).

**7. How long does it take?**\
For 100 job URLs with concurrency 10, approximately 1–2 minutes, depending on network speed and server response times.

**8. Can I add my own stop words?**\
You can modify the `STOP_WORDS` list in the script – the actor is open source. For the hosted version, the list is predefined but comprehensive.

**9. What does `top_required_keywords` include?**\
The most frequent (non‑stop) words and bigrams in the job description, up to 20. These are the terms the employer emphasizes.

**10. Is there a free trial?**\
Apify gives new users $5 monthly credit, which is enough to test this actor for a month (or run it dozens of times). After that, it’s $7.99/month – cancel anytime.

***

***

### 🔍 SEO Keywords

`job description keyword analyzer`, `resume to job description matcher`, `keyword extraction for jobs`, `CV optimizer`, `job match score`, `ATS keyword checker`, `resume tailoring tool`, `job description text analyzer`, `recruitment automation`, `career optimization`, `Apify job matcher`

***

### 🔗 Related Actors

- **[Amazon Product Scraper – ASIN, Price, Rating, Reviews](https://apify.com/your-username/amazon-product-scraper)**
- **[NHS Job Scraper – Salary, Band, Employer, Location](https://apify.com/your-username/nhs-job-scraper)**
- **[Instagram Profile Scraper – Followers, Bio, Posts, Verified](https://apify.com/your-username/instagram-profile-scraper)**

***

***

**Start optimizing your resume for every job application – only $7.99/month. Upload your resume, add job URLs, and get instant keyword match scores.**

````

# Actor input Schema

## `resumeText` (type: `string`):

Paste the full text of your resume here.
## `jobUrls` (type: `array`):

Add links to job postings (LinkedIn, Indeed, Company sites).
## `jobDescriptionsText` (type: `array`):

Alternatively, paste raw job description text here if URLs are blocked or require login.
## `maxConcurrency` (type: `integer`):

Maximum number of URLs to process simultaneously.
## `proxyConfiguration` (type: `object`):

Use Residential proxies if fetching URLs from strict sites.

## Actor input object example

```json
{
  "resumeText": "I am a software engineer with 5 years of experience in Python, JavaScript, and React...",
  "jobUrls": [
    {
      "url": "https://example.com/job/123"
    }
  ],
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "resumeText": "I am a software engineer with 5 years of experience in Python, JavaScript, and React...",
    "jobUrls": [
        {
            "url": "https://example.com/job/123"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/job-description-keyword-analyzer-match-resume-score").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 = {
    "resumeText": "I am a software engineer with 5 years of experience in Python, JavaScript, and React...",
    "jobUrls": [{ "url": "https://example.com/job/123" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/job-description-keyword-analyzer-match-resume-score").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 '{
  "resumeText": "I am a software engineer with 5 years of experience in Python, JavaScript, and React...",
  "jobUrls": [
    {
      "url": "https://example.com/job/123"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/job-description-keyword-analyzer-match-resume-score --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilot/job-description-keyword-analyzer-match-resume-score",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Description Keyword Analyzer – Match Resume Score",
        "description": "Paste your resume, add job URLs or text – get match score, top required keywords, matched & missing keywords. Tailor your CV for each application. Bulk processing, checkpoint/resume. $7.99/month unlimited.",
        "version": "0.0",
        "x-build-id": "iqd8tD8hxwpfyfdQM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~job-description-keyword-analyzer-match-resume-score/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-job-description-keyword-analyzer-match-resume-score",
                "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/scrapepilot~job-description-keyword-analyzer-match-resume-score/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-job-description-keyword-analyzer-match-resume-score",
                "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/scrapepilot~job-description-keyword-analyzer-match-resume-score/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-job-description-keyword-analyzer-match-resume-score",
                "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",
                "required": [
                    "resumeText"
                ],
                "properties": {
                    "resumeText": {
                        "title": "Your Resume Text (*Required)",
                        "type": "string",
                        "description": "Paste the full text of your resume here."
                    },
                    "jobUrls": {
                        "title": "Job Description URLs",
                        "type": "array",
                        "description": "Add links to job postings (LinkedIn, Indeed, Company sites).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "jobDescriptionsText": {
                        "title": "Job Descriptions (Plain Text)",
                        "type": "array",
                        "description": "Alternatively, paste raw job description text here if URLs are blocked or require login.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "type": "integer",
                        "description": "Maximum number of URLs to process simultaneously.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Use Residential proxies if fetching URLs from strict sites."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
