# LinkedIn Hiring Posts Scraper 🚀 (`apt_marble/linkedin-hiring-posts-scraper`) Actor

Find companies actively hiring from public LinkedIn posts 🚀 Extract recruiter names, hiring roles, companies, locations, post URLs, and fresh hiring intent data by keyword, industry, or location — no LinkedIn login or cookies required.

- **URL**: https://apify.com/apt\_marble/linkedin-hiring-posts-scraper.md
- **Developed by:** [Hamza](https://apify.com/apt_marble) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 6 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Hiring Posts Scraper

**Find companies that are actively hiring right now — straight from public LinkedIn posts. Fresh hiring intent data, no LinkedIn login or cookies required.**

This actor surfaces the companies whose recruiters, founders, or HR leaders are publishing hiring posts on LinkedIn. You get the company, the role being hired, who's posting, a hiring-intent score, and a direct link to the post — perfect for staffing firms, sales prospecting, recruiting, and outreach.

---

### Why this is the highest-signal lead source on LinkedIn

People posting "we are hiring" on LinkedIn aren't *thinking about* growing. They're spending money right now. Every record this actor produces is a company that:

- Has open headcount and an active budget
- Has named the role they need
- Is broadcasting it publicly today (not three quarters ago)

That makes the dataset gold for: recruiting agencies pitching roles, staffing firms identifying ICP, HRTech founders running ABM, and account executives selling anything growth-related.

---

### What you get back

Each row in the dataset is one LinkedIn hiring post:

```json
{
    "postUrl": "https://www.linkedin.com/posts/technovaco_we-are-hiring-software-engineers-activity-1234567890",
    "hiringCompany": "TechNova",
    "recruiterName": "John Smith",
    "hiringRole": "Software Engineer",
    "postSnippet": "John Smith is hiring React developers for TechNova in Berlin...",
    "hiringIntent": "Medium",
    "hiringKeywordMatched": "we are hiring",
    "jobRoleMatched": "Software Engineer",
    "industryKeyword": "SaaS",
    "locationKeyword": "Germany",
    "postDate": "3 days ago",
    "timestamp": "2026-05-23T12:00:00Z"
}
````

The full field list:

| Field | What it is |
|---|---|
| `postUrl` | Direct link to the LinkedIn post |
| `hiringCompany` | The company doing the hiring (best-effort extraction) |
| `recruiterName` | The post author (when the post is by a person, not a company page) |
| `hiringRole` | The detected role being hired |
| `postSnippet` | Raw snippet text from the result |
| `hiringIntent` | `High` / `Medium` / `Low` urgency classification |
| `hiringKeywordMatched` | Which hiring phrase from your input surfaced this post |
| `jobRoleMatched` | The role bucket the query targeted |
| `industryKeyword` | The industry filter used (if any) |
| `locationKeyword` | The location filter used (if any) |
| `postDate` | Human-readable "X days ago" hint when present |
| `timestamp` | ISO 8601 scrape time |

Export to CSV, JSON, Excel, or pipe directly into HubSpot, Salesforce, Clay, Apollo, or any HTTP webhook.

***

### Inputs

| Field | Type | What it does |
|---|---|---|
| **Hiring Intent Phrases** | `array<string>` | Hiring phrases to search for. Defaults to `we are hiring, looking for, join our team`. Add `now hiring`, `urgently hiring`, `open position`, `job opening`, `hiring immediately`. |
| **Job Roles** | `array<string>` | Specific roles to focus on (`Software Engineer`, `AI Engineer`, `Marketing Manager`, `Sales Representative`). Optional. |
| **Industry / Tech Keywords** | `array<string>` | Industry tags (`SaaS`, `Fintech`, `Healthcare`) or technologies (`React`, `Python`, `AI`). Optional. |
| **Locations** | `array<string>` | Country / region / city filters (`United States`, `Berlin`). Optional. |
| **Maximum Posts** | `integer` | Stop after collecting N unique posts. Default `100`. |
| **Search Language** | `string` | Language hint. Default `en`. |
| **Deduplicate Results** | `boolean` | Drop duplicate post URLs across the run. Default `true`. |

The actor expands every combination of (industry × location) using the OR-grouped hiring-phrase and role buckets. So 2 industries × 2 locations = 4 internal searches, all deduplicated into one clean dataset.

***

### Hiring-intent scoring

Each post gets one of three labels based on urgency cues in the title + snippet:

| Tier | Trigger words |
|---|---|
| **High** | `urgently hiring`, `urgent`, `hiring immediately`, `immediate opening`, `asap`, `must hire` |
| **Medium** | `now hiring`, `we are hiring`, `we're hiring`, `open position`, `open role`, `job opening`, `join our team`, `new role` |
| **Low** | `looking for`, `seeking`, `recruiting for`, `on the lookout` |

If nothing matches, `hiringIntent` is `null`. Use this field to triage: send your highest-priority outreach to `High` intent posts first.

***

### Example use cases

**Staffing agency prospecting** — `hiringKeywords: ["we are hiring", "urgently hiring"]`, `jobRoles: ["Software Engineer", "AI Engineer"]`, `locations: ["United States"]`. Pull the list, filter `hiringIntent = High`, contact those companies tomorrow morning.

**HRTech ABM list** — `hiringKeywords: ["we are hiring"]`, `keywords: ["SaaS", "B2B"]`. Build a growing-companies-only ICP list to invite to your webinar.

**Job seekers** — `hiringKeywords: ["we are hiring", "looking for"]`, `jobRoles: ["Frontend Developer", "React Developer"]`, `locations: ["Berlin", "Amsterdam"]`. See exactly which companies are hiring your stack in your city this week.

**Sales prospecting** — Companies posting hiring content are growing fast. Whatever you sell (analytics, payroll, devtools, infrastructure), they're spending money. Run this weekly to keep your pipeline fresh.

**Investor / market intel** — Track hiring intensity by industry vertical month over month. Spot companies scaling fast before press coverage catches up.

***

### Tips that save you time and money

- **Start with the urgent phrases.** `urgently hiring` and `hiring immediately` return fewer but much higher-quality leads. Stack them with `we are hiring` for broader coverage.
- **Add a role filter to cut noise.** Searching just `we are hiring` returns mixed content — adding `Software Engineer` or `Account Executive` returns just the posts hiring for that role.
- **Locations are loose.** They match as phrases anywhere in the post, so you'll see some noise. Run per-country for clean segmentation.
- **Sort by `hiringIntent` in your CSV.** Triage `High → Medium → Low` so cold outreach goes to the hottest leads first.
- **Watch `postDate`.** Posts from "2 weeks ago" or older are less urgent than posts from "today" — many hiring needs are filled fast.

***

### Pricing — pay only for what you extract

This actor uses Apify's **pay-per-event** pricing. You're billed per post delivered to your dataset, plus a one-time start fee. No charge if a run returns zero results.

| Apify Plan    | Start Fee | Per Profile |
| ------------- | --------- | ----------- |
| Free / Bronze | $0.0025   | $0.0025     |
| Silver        | $0.0025   | ~$0.0022    |
| Gold          | $0.0025   | ~$0.0020    |
| Platinum      | $0.0025   | ~$0.0018    |
| Diamond       | $0.0025   | ~$0.0015    |

**Real-world cost examples:**

- 25 posts for a test run: about **$0.06**
- 250 hiring posts across the US & Canada: about **$0.63**
- 2,000 posts across 10 industries: about **$5.00**

The Free Apify plan ships with $5/month of credit — plenty for several real lead lists.

***

### Frequently asked

**Do I need a LinkedIn account or Sales Navigator?**
No. The actor never logs into LinkedIn, never asks for cookies, and never touches your account. It only returns posts that are publicly accessible.

**Will this get me LinkedIn-banned?**
No. There's no account activity for LinkedIn to flag.

**How fresh is the data?**
You're seeing posts as soon as they're indexed publicly. The `postDate` field gives you a relative timestamp (when present) so you can prioritize the most recent.

**How accurate is the `hiringCompany` field?**
Very accurate when the post is by a company page (`Acme Corp on LinkedIn: …`) or contains an explicit `at <Company>` mention. Less accurate when an individual recruiter posts vaguely about hiring without naming the employer — in those cases the field may be null and you'll have to consult `postSnippet`.

**How accurate is the `hiringRole` field?**
Catalogue-based matching against ~50 common roles plus your custom `jobRoles` list, with a regex fallback for `hiring <Role>` patterns. If you supply explicit roles in `jobRoles`, they take priority — so the field will surface "Senior React Engineer" instead of just "Engineer" when you asked for it.

**Will I get duplicates if I run it twice?**
Within a single run, no — dedup is on by default. Across runs, yes — track previously seen `postUrl` values in your own pipeline.

**Can I schedule this?**
Yes, and you probably should. Apify Schedules let you run it daily or weekly to catch fresh hiring posts in your target industry. Combine with a webhook to push new rows into HubSpot, Salesforce, Notion, or Google Sheets.

**The actor returned 0 results — what's wrong?**
(1) Make sure your hiring phrases are common public ones — `we are hiring` returns far more than `currently seeking outstanding candidates for…`. (2) Try removing the `Locations` filter to see if you're over-narrowing. (3) Add more role / industry combinations.

***

### A note on responsible use

This actor extracts public posts and the metadata around them. It does not bypass authentication, log into accounts, scrape private content, or pull anything beyond what any anonymous visitor could see.

That said: **outreach based on hiring intent is still cold outreach**. Don't pretend to be applying for the job, don't blast template messages, and respect GDPR / CCPA / similar regulations in your jurisdiction. The companies in your dataset are humans dealing with hiring — treat them that way and your reply rates will be much higher.

***

### Drop it into your workflow

- **Apify Schedules** → run it daily or weekly to catch fresh hiring signals
- **Zapier / Make** → push new rows into HubSpot, Salesforce, Notion, Slack
- **Apify Webhook** → POST results to your server for custom routing
- **Pair with an email-finder** → use `recruiterName + hiringCompany` to resolve email addresses in Clay, Apollo, or Hunter
- **Pair with a LinkedIn Profile Scraper** → enrich the `recruiterName` field with full job history

Run it once with a small `maxResults` to see what you get. The first 25 posts are usually cheap enough to taste-test before committing.

# Actor input Schema

## `hiringKeywords` (type: `array`):

Hiring phrases to find on LinkedIn posts. Common picks: `we are hiring`, `looking for`, `join our team`, `now hiring`, `open position`, `urgently hiring`, `hiring immediately`, `job opening`.

## `jobRoles` (type: `array`):

Specific roles to search for (`Software Engineer`, `AI Engineer`, `Marketing Manager`, `Sales Representative`, `Product Manager`, `Data Scientist`). Optional — leave empty to discover hiring posts across all roles.

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

Industry tags (`SaaS`, `Fintech`, `Healthcare`, `Cybersecurity`) or technologies (`React`, `Python`, `AI`). Used to narrow hiring posts to specific verticals. Optional.

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

Country, region, or city filters (`United States`, `Germany`, `Dubai`, `London`). Optional.

## `maxResults` (type: `integer`):

Stop after collecting this many unique hiring posts.

## `language` (type: `string`):

Language hint for the search (`en`, `fr`, `de`, `es`, `pt`, etc.).

## `deduplicateResults` (type: `boolean`):

Drop duplicate posts based on the canonical post URL.

## Actor input object example

```json
{
  "hiringKeywords": [
    "we are hiring",
    "looking for",
    "join our team"
  ],
  "jobRoles": [
    "Software Engineer"
  ],
  "keywords": [],
  "locations": [
    "United States"
  ],
  "maxResults": 100,
  "language": "en",
  "deduplicateResults": true
}
```

# 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 = {
    "hiringKeywords": [
        "we are hiring",
        "looking for",
        "join our team"
    ],
    "jobRoles": [
        "Software Engineer"
    ],
    "keywords": [],
    "locations": [
        "United States"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apt_marble/linkedin-hiring-posts-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 = {
    "hiringKeywords": [
        "we are hiring",
        "looking for",
        "join our team",
    ],
    "jobRoles": ["Software Engineer"],
    "keywords": [],
    "locations": ["United States"],
}

# Run the Actor and wait for it to finish
run = client.actor("apt_marble/linkedin-hiring-posts-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 '{
  "hiringKeywords": [
    "we are hiring",
    "looking for",
    "join our team"
  ],
  "jobRoles": [
    "Software Engineer"
  ],
  "keywords": [],
  "locations": [
    "United States"
  ]
}' |
apify call apt_marble/linkedin-hiring-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Hiring Posts Scraper 🚀",
        "description": "Find companies actively hiring from public LinkedIn posts 🚀 Extract recruiter names, hiring roles, companies, locations, post URLs, and fresh hiring intent data by keyword, industry, or location — no LinkedIn login or cookies required.",
        "version": "0.0",
        "x-build-id": "Xp8SppLiLE3vNWP1V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apt_marble~linkedin-hiring-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apt_marble-linkedin-hiring-posts-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/apt_marble~linkedin-hiring-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apt_marble-linkedin-hiring-posts-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/apt_marble~linkedin-hiring-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apt_marble-linkedin-hiring-posts-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",
                "required": [
                    "hiringKeywords"
                ],
                "properties": {
                    "hiringKeywords": {
                        "title": "🔥 Hiring Intent Phrases",
                        "type": "array",
                        "description": "Hiring phrases to find on LinkedIn posts. Common picks: `we are hiring`, `looking for`, `join our team`, `now hiring`, `open position`, `urgently hiring`, `hiring immediately`, `job opening`.",
                        "default": [
                            "we are hiring",
                            "looking for",
                            "join our team"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobRoles": {
                        "title": "Job Roles",
                        "type": "array",
                        "description": "Specific roles to search for (`Software Engineer`, `AI Engineer`, `Marketing Manager`, `Sales Representative`, `Product Manager`, `Data Scientist`). Optional — leave empty to discover hiring posts across all roles.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Industry / Tech Keywords",
                        "type": "array",
                        "description": "Industry tags (`SaaS`, `Fintech`, `Healthcare`, `Cybersecurity`) or technologies (`React`, `Python`, `AI`). Used to narrow hiring posts to specific verticals. Optional.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Country, region, or city filters (`United States`, `Germany`, `Dubai`, `London`). Optional.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Posts",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Stop after collecting this many unique hiring posts.",
                        "default": 100
                    },
                    "language": {
                        "title": "Search Language",
                        "type": "string",
                        "description": "Language hint for the search (`en`, `fr`, `de`, `es`, `pt`, etc.).",
                        "default": "en"
                    },
                    "deduplicateResults": {
                        "title": "Deduplicate Results",
                        "type": "boolean",
                        "description": "Drop duplicate posts based on the canonical post URL.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```