# LinkedIn Jobs Scraper (`fetch_cat/linkedin-jobs-scraper`) Actor

Scrape public LinkedIn job postings by keyword, location, and start URLs. Export titles, companies, locations, descriptions, criteria, and direct job links.

- **URL**: https://apify.com/fetch\_cat/linkedin-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## LinkedIn Jobs Scraper

Scrape public LinkedIn job postings by keyword, location, and LinkedIn jobs search URLs.

Find roles, companies, descriptions, seniority, employment type, industries, applicant text, and direct job URLs in a clean dataset.

Use it for recruiting research, job aggregation, market maps, compensation research, lead discovery, and labor-market tracking.

### Job data workflow

Use [LinkedIn Jobs Scraper](https://apify.com/fetch_cat/linkedin-jobs-scraper) for marketplace job postings by keyword and location.

Use [Workday Jobs Scraper](https://apify.com/fetch_cat/workday-jobs-scraper) and [Greenhouse Jobs Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper) for company ATS boards.

Join outputs by company, title, location, and job URL to build recruiting research, hiring-signal, and labor-market datasets.

### What does LinkedIn Jobs Scraper do?

LinkedIn Jobs Scraper collects public job posting data from LinkedIn Jobs.

You can search by keyword and location.

You can also paste public LinkedIn jobs search URLs.

The Actor saves one dataset row per job posting.

Each row includes the job ID, title, company, location, posting age, job URL, and optional detail fields.

When detail fetching is enabled, the Actor also collects the public description and job criteria shown by LinkedIn.

### Who is it for?

Recruiters use it to monitor hiring demand by role and location.

Talent teams use it to build target company lists.

Job boards use it to collect public postings for aggregation workflows.

Labor-market analysts use it to track skill demand.

Sales teams use it to find companies hiring for roles related to their product.

Investors use it to watch hiring velocity at portfolio or target companies.

Students and job seekers use it to export matching roles for comparison.

### Why use this Actor?

✅ Export public LinkedIn jobs into structured JSON, CSV, Excel, or API responses.

✅ Search multiple keywords in one run.

✅ Filter by location, date posted, workplace type, and sort order.

✅ Include or skip descriptions depending on speed and cost needs.

✅ Deduplicate jobs by LinkedIn job ID across searches.

✅ Use Apify integrations, webhooks, schedules, and datasets.

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId` | LinkedIn job identifier |
| `title` | Job title |
| `companyName` | Company name |
| `companyUrl` | Public company page URL when available |
| `location` | Job location text |
| `postedAtText` | Public posted-age text |
| `jobUrl` | Direct public LinkedIn job URL |
| `description` | Public job description when detail fetching is enabled |
| `employmentType` | Employment type when visible |
| `seniorityLevel` | Seniority level when visible |
| `industries` | Industry text when visible |
| `applicantsText` | Public applicant count text when visible |
| `sourceSearchUrl` | Search page that produced the job |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape LinkedIn jobs?

This Actor uses pay-per-event pricing.

You pay a $0.005 start fee per run and a tiered per-result fee for each saved job posting.

The BRONZE result price is $0.000051787 per job, which is about $0.051787 per 1,000 saved jobs before Apify account-tier discounts.

Higher Apify tiers receive lower per-result prices shown on the Pricing tab.

Keep `maxItems` low for quick tests.

Increase `maxItems` for production monitoring once your query is returning the roles you need.

### How to use LinkedIn Jobs Scraper

1. Open the Actor on Apify.

2. Enter one or more keywords, such as `software engineer` or `product manager`.

3. Add a location, such as `United States`, `London`, or `Remote`.

4. Choose how many jobs to save.

5. Decide whether to include job descriptions.

6. Run the Actor.

7. Download the dataset or connect it to your workflow.

### Input options

#### Keywords

Use one or more job searches.

Examples:

- `software engineer`
- `data analyst`
- `nurse`
- `sales development representative`

#### Location

Use the location wording you would type into LinkedIn Jobs.

Examples:

- `United States`
- `Canada`
- `London`
- `Berlin`
- `Remote`

#### Start URLs

You can paste public LinkedIn jobs search URLs.

This is useful when you already built a search in LinkedIn and want to run the same search on Apify.

#### Maximum jobs

`maxItems` caps the total jobs saved across all keywords and URLs.

Start with 10–25 jobs for a test run.

Use a larger value for scheduled monitoring.

#### Include job descriptions

When enabled, the Actor visits each public job detail page.

This adds fields such as description, employment type, seniority, industries, and applicant text.

Disable it if you only need fast search-card data.

#### Date posted

Choose any time, past 24 hours, past week, or past month.

#### Workplace type

Choose any, on-site, remote, or hybrid.

#### Sort by

Choose relevance or most recent.

### Output example

```json
{
  "jobId": "4374834620",
  "title": "Software Engineer (New Grads)",
  "companyName": "Giga",
  "companyUrl": "https://www.linkedin.com/company/gigaml",
  "location": "New York, NY",
  "postedAtText": "5 days ago",
  "jobUrl": "https://www.linkedin.com/jobs/view/software-engineer-new-grads-at-giga-4374834620",
  "description": "About Giga...",
  "employmentType": "Volunteer",
  "seniorityLevel": "Not Applicable",
  "industries": "Software Development",
  "applicantsText": "Over 200 applicants",
  "sourceSearchUrl": "https://www.linkedin.com/jobs-guest/jobs/api/seeMoreJobPostings/search?...",
  "scrapedAt": "2026-06-17T11:13:45.322Z"
}
````

### Tips for better results

Use specific role keywords.

Use one region per run for cleaner datasets.

Use `sortBy: recent` for monitoring new roles.

Use `datePosted: past24h` for daily alerts.

Keep descriptions enabled when you need skills, requirements, or full text.

Disable descriptions when you only need company, title, and URL lists.

### Common recruiting workflows

Track target companies hiring for AI, security, data, or sales roles.

Build lead lists of companies hiring roles that match your product.

Monitor remote job supply by title.

Compare hiring demand by geography.

Export jobs into an ATS enrichment workflow.

### Market research workflows

Measure how often companies mention a skill in descriptions.

Track demand for roles across locations.

Compare industries hiring for a function.

Build weekly datasets for dashboards.

Detect companies expanding specific teams.

### Integrations

Use Apify schedules to run daily or weekly.

Use webhooks to trigger downstream processing after each run.

Export to Google Sheets, Make, Zapier, Airtable, or your own API.

Use dataset API endpoints to pull the newest results into a dashboard.

Combine with enrichment Actors to add company websites, emails, or firmographic data.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/linkedin-jobs-scraper').call({
  keywords: ['software engineer'],
  location: 'United States',
  maxItems: 25,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('fetch_cat/linkedin-jobs-scraper').call(run_input={
    'keywords': ['software engineer'],
    'location': 'United States',
    'maxItems': 25,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~linkedin-jobs-scraper/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["software engineer"],"location":"United States","maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this Actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/linkedin-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-linkedin-jobs https://mcp.apify.com/?tools=fetch_cat/linkedin-jobs-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-linkedin-jobs": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/linkedin-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Find 50 recent remote data analyst jobs and summarize the most common tools."
- "Scrape software engineer jobs in Berlin and group them by company."
- "Run the LinkedIn Jobs Scraper for product manager roles in London and export the dataset URL."

### Scheduling

Create an Apify schedule for recurring job monitoring.

For daily alerts, use `datePosted: past24h` and `sortBy: recent`.

For weekly market reports, use `datePosted: pastWeek` and a larger `maxItems` value.

### Limits and caveats

Only public job data is collected.

LinkedIn can change page structure or rate-limit heavy traffic.

Some jobs do not show every detail field publicly.

Applicant counts are public text and may be approximate.

Descriptions can be long, so exports may contain large text fields.

### FAQ

#### Can I scrape jobs without a LinkedIn account?

Yes. This Actor is designed for public job postings that are visible without logging in.

#### Can I run this every day?

Yes. Use Apify schedules with recent-date filters for daily monitoring.

### Troubleshooting

#### Why did my run return fewer jobs than requested?

The search may have fewer public jobs than your `maxItems` setting, or LinkedIn may return repeated jobs that are deduplicated.

Try broader keywords, another location, or a longer date range.

#### Why are some detail fields empty?

Some LinkedIn postings do not publicly show seniority, employment type, industries, applicant text, or descriptions in the same way.

The Actor still saves the search-card fields and leaves unavailable fields empty.

#### Should I use a proxy?

The default input uses Apify Proxy with datacenter-style settings.

For small tests, direct requests may work.

For larger scheduled runs, a proxy is safer.

### Legality

This Actor is designed for publicly available job posting data.

Do not scrape private data, account-only pages, or personal data you are not allowed to process.

Make sure your use complies with applicable laws, LinkedIn terms, and privacy rules.

If you process personal data, establish a lawful basis and retention policy.

### Related scrapers

Explore more Actors from fetch\_cat:

- https://apify.com/fetch\_cat/reddit-scraper
- https://apify.com/fetch\_cat/craigslist-classifieds-scraper
- https://apify.com/fetch\_cat/y-combinator-companies-scraper
- https://apify.com/fetch\_cat/apple-app-store-reviews-scraper

### Changelog

Initial version: scrape public LinkedIn job search results and optional public detail fields.

### Support

If a run fails, share the run ID and input configuration.

Include whether the issue happens with keyword search, start URLs, detail fetching, or a specific filter.

### Summary

LinkedIn Jobs Scraper turns public LinkedIn job postings into structured datasets.

It is useful for recruiting, lead generation, job aggregation, and labor-market research.

Start small, verify your query, then schedule recurring runs for ongoing monitoring.

# Actor input Schema

## `keywords` (type: `array`):

Job title, skill, company, or query to search for. You can enter one or more searches.

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

LinkedIn location text, such as United States, London, Berlin, or Remote.

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

Optional LinkedIn public jobs search URLs. If provided, these are scraped in addition to keyword searches.

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

Maximum number of job postings to save across all searches.

## `includeDetails` (type: `boolean`):

Fetch each public job detail page to include description, seniority level, employment type, industries, and applicant text.

## `datePosted` (type: `string`):

Filter results by LinkedIn's public date-posted options.

## `workplaceType` (type: `string`):

Filter by on-site, remote, or hybrid roles.

## `sortBy` (type: `string`):

Choose LinkedIn relevance ranking or newest jobs first.

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

Use Apify Proxy if LinkedIn rate-limits your requests. Start with the default Apify Proxy configuration and switch groups only if needed.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "datePosted": "any",
  "workplaceType": "any",
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": [
        "software engineer"
    ],
    "location": "United States",
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/linkedin-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["software engineer"],
    "location": "United States",
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/linkedin-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "software engineer"
  ],
  "location": "United States",
  "startUrls": []
}' |
apify call fetch_cat/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper",
        "description": "Scrape public LinkedIn job postings by keyword, location, and start URLs. Export titles, companies, locations, descriptions, criteria, and direct job links.",
        "version": "0.1",
        "x-build-id": "V97smfrAFx81bfn17"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-linkedin-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job title, skill, company, or query to search for. You can enter one or more searches.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "LinkedIn location text, such as United States, London, Berlin, or Remote."
                    },
                    "startUrls": {
                        "title": "LinkedIn jobs start URLs",
                        "type": "array",
                        "description": "Optional LinkedIn public jobs search URLs. If provided, these are scraped in addition to keyword searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job postings to save across all searches.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Fetch each public job detail page to include description, seniority level, employment type, industries, and applicant text.",
                        "default": true
                    },
                    "datePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "past24h",
                            "pastWeek",
                            "pastMonth"
                        ],
                        "type": "string",
                        "description": "Filter results by LinkedIn's public date-posted options.",
                        "default": "any"
                    },
                    "workplaceType": {
                        "title": "Workplace type",
                        "enum": [
                            "any",
                            "onsite",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Filter by on-site, remote, or hybrid roles.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Choose LinkedIn relevance ranking or newest jobs first.",
                        "default": "relevance"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy if LinkedIn rate-limits your requests. Start with the default Apify Proxy configuration and switch groups only if needed.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
