# LinkedIn Ads Scraper (`crawlerbros/linkedin-ads-scraper`) Actor

Extract ads from the public LinkedIn Ad Library by keyword, advertiser, country, and date range. Returns headline, body, advertiser info, media URLs, impressions, targeting, and dates. No login required.

- **URL**: https://apify.com/crawlerbros/linkedin-ads-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Ads Scraper

Extract ads from the **public LinkedIn Ad Library** (`linkedin.com/ad-library`) by keyword, advertiser, country, or date range. Returns headline, body copy, advertiser info, media URLs, CTA, and — with optional detail-page enrichment — `paid_for_by`, canonical advertiser URL, and full body text.

**No login or LinkedIn account required.** The Ad Library is fully public and the actor runs without cookies.

The scraper covers every advertiser visible in LinkedIn's Ad Library across all supported countries — built for ad intelligence, competitive research, lead generation, and brand monitoring.

### What you get

For each ad on the search results page:

| Field | Description |
| --- | --- |
| `ad_id` | LinkedIn ad / creative identifier |
| `ad_url` | Direct LinkedIn Ad Library detail URL |
| `ad_format` | `image` / `video` / `carousel` / `document` / `text` / `inmail` |
| `advertiser_name` | Sponsoring entity (company or person) |
| `advertiser_logo` | Logo image URL |
| `advertiser_tagline` | Sponsoring entity tagline (e.g. "Chief AI Officer") |
| `advertiser_url` | LinkedIn company page URL |
| `body_text` | Ad commentary / body copy as shown in the preview |
| `headline` | Ad headline copy |
| `cta_text` | Call-to-action text (e.g. "Learn more", "Apply now") |
| `cta_url` | Click-through destination URL |
| `media_urls` | All image / video / document / carousel slide URLs |
| `scraped_at` | ISO 8601 UTC timestamp of extraction |

When `enrichWithDetailPage=true` is enabled, additional fields are pulled from each ad's detail page:

| Field | Description |
| --- | --- |
| `paid_for_by` | Entity that paid for the ad (often differs from the advertiser) |
| `body_text_full` | Full body / commentary text from the detail page (sometimes longer than the preview) |
| `advertiser_url` | Canonical advertiser URL — overrides the search-result URL when richer |

Empty fields are dropped from each record so the dataset stays clean — you only see fields that were actually populated.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `searchTerms` | Array | `[]` | Keyword search queries (e.g. `"AI"`, `"remote work"`). Matched against ad copy and advertiser name. |
| `advertisers` | Array | `[]` | Advertiser / company names (e.g. `"Microsoft"`, `"Salesforce"`). |
| `countries` | Array | `[]` | ISO-3166-1 alpha-2 country codes (e.g. `"US"`, `"GB"`, `"IN"`). |
| `dateOption` | Enum | `last-30-days` | `last-30-days` / `last-90-days` / `last-year` / `custom` |
| `dateFrom` | String | — | YYYY-MM-DD, only used when `dateOption=custom`. |
| `dateTo` | String | — | YYYY-MM-DD, only used when `dateOption=custom`. |
| `directUrls` | Array | `[]` | Pre-built Ad Library URLs — paste directly if you already configured filters in the LinkedIn UI. |
| `maxResults` | Integer | `50` | Maximum ads to return across all queries. |
| `enrichWithDetailPage` | Boolean | `false` | Open each ad's detail page to add `paid_for_by`, full body text, and canonical advertiser URL. Slower but more complete. |
| `proxy` | Object | Apify Proxy | Defaults to free Apify Proxy (no residential group needed). |

You can combine inputs freely — every keyword × advertiser combination is tried, scoped by your country and date filters.

#### Example input — keyword search, fast

```json
{
  "searchTerms": ["AI", "machine learning"],
  "countries": ["US"],
  "dateOption": "last-30-days",
  "maxResults": 50
}
````

#### Example input — advertiser focus, full enrichment

```json
{
  "advertisers": ["Microsoft", "Salesforce"],
  "dateOption": "last-90-days",
  "maxResults": 100,
  "enrichWithDetailPage": true
}
```

#### Example input — direct Ad Library URL

```json
{
  "directUrls": [
    { "url": "https://www.linkedin.com/ad-library/search?keyword=cloud&country=US" }
  ]
}
```

#### Example input — custom date range

```json
{
  "searchTerms": ["recruiting"],
  "dateOption": "custom",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31"
}
```

### Example output

```json
{
  "ad_id": "12345678",
  "ad_url": "https://www.linkedin.com/ad-library/detail/12345678",
  "ad_format": "video",
  "advertiser_name": "Anthropic",
  "advertiser_url": "https://www.linkedin.com/company/anthropicresearch",
  "advertiser_logo": "https://media.licdn.com/dms/image/.../company-logo.jpg",
  "headline": "Build with Claude",
  "body_text": "Ship faster with the Claude API. Trusted by 1000s of developers.",
  "cta_text": "Learn more",
  "cta_url": "https://www.anthropic.com/api",
  "media_urls": ["https://media.licdn.com/dms/image/.../ad-creative.jpg"],
  "paid_for_by": "Anthropic PBC",
  "body_text_full": "Ship faster with the Claude API. Trusted by 1000s of developers building agents, RAG pipelines, coding assistants, and more.",
  "scraped_at": "2026-05-05T13:42:18Z"
}
```

### Use cases

- **Competitive intelligence** — Monitor what competitors are running, in which countries, with what messaging.
- **Lead generation** — Build prospect lists of companies actively spending on LinkedIn ads in your category.
- **Brand monitoring** — Track every ad featuring your brand, products, or trademarks.
- **Creative research** — Mine patterns in headline length, CTA choice, and media format across an industry.
- **Geographic analysis** — Compare ad strategies across markets by combining country + advertiser filters.
- **Compliance / due diligence** — Verify what an advertiser is publicly claiming on LinkedIn (`paid_for_by` shows the actual paying entity).

### FAQ

**Do I need a LinkedIn account?**
No. The Ad Library is fully public — anyone can browse it without logging in. The actor makes the same anonymous requests the public web UI does.

**Do I need a proxy?**
No. The default Apify Proxy (no residential group required) works out of the box.

**What's the difference between `searchTerms` and `advertisers`?**

- `searchTerms` matches ad copy AND advertiser name (broad keyword search).
- `advertisers` matches only the advertiser display name (narrow company-targeted search).

Combine them when you want to find a specific company's ads about a specific topic.

**When should I enable `enrichWithDetailPage`?**
Whenever you need `paid_for_by` (regulatory / compliance use cases), the canonical advertiser URL, or the full body text. Each ad adds ~1-2 s to the run, so it roughly doubles total runtime — leave it off for fast list pulls and turn it on for high-value reporting.

**What does `dateOption=custom` enable?**
A user-defined `dateFrom` / `dateTo` window. LinkedIn returns ads served at any time during that window. Without `custom`, the actor uses LinkedIn's predefined buckets (last 30 / 90 / 365 days).

**How many ads can I scrape per run?**
LinkedIn's UI typically renders 25-50 ads per query results page. Adjust `maxResults` up to 1000 to span multiple queries. For larger pulls, run multiple actor invocations with different keyword / country slices.

**What if a query returns no ads?**
The actor returns an empty result for that query and continues with the rest. If every query returns zero ads, a single sentinel record with `type: "linkedin_ads_blocked"` is emitted so the run exits cleanly with a non-empty dataset.

**Why are some fields like impression counts or targeting missing?**
LinkedIn only publishes impression ranges and targeting facets in jurisdictions where the EU Digital Services Act mandates it, and only for ads that have served above an activity threshold. Records without that data simply omit those fields.

**How current is the data?**
Live — every run hits LinkedIn at request time. Schedule the actor for daily / hourly refreshes.

**Can I scrape closed / paused ads?**
Yes — the Ad Library shows ads served at any point in the last 12 months, including those no longer active.

### Limitations

- Only ads visible in the public Ad Library are scraped — no access to LinkedIn's full Campaign Manager.
- Impression counts (when present) are LinkedIn's published ranges (e.g. "10K-50K"), not exact figures.
- Targeting facets are sparse outside DSA-regulated jurisdictions.
- LinkedIn may rate-limit aggressive crawling; the scraper rotates TLS fingerprints and randomises delays to stay polite.

# Actor input Schema

## `searchTerms` (type: `array`):

Keyword search queries (e.g., 'AI', 'cloud computing'). The Ad Library matches ads whose copy or advertiser contains any of these terms.

## `advertisers` (type: `array`):

Advertiser / company names to search (e.g., 'Microsoft', 'Salesforce'). LinkedIn matches the advertiser display name.

## `countries` (type: `array`):

ISO-3166-1 alpha-2 country codes (e.g., 'US', 'GB', 'IN'). Filters ads to those served in the selected countries.

## `dateOption` (type: `string`):

Pre-defined date window. Use 'custom' to specify exact dateFrom/dateTo.

## `dateFrom` (type: `string`):

Start date for custom range (YYYY-MM-DD). Only used when dateOption=custom.

## `dateTo` (type: `string`):

End date for custom range (YYYY-MM-DD). Only used when dateOption=custom.

## `directUrls` (type: `array`):

Pre-built LinkedIn Ad Library URLs. Use this if you've already configured filters on linkedin.com/ad-library and just want to paste the URL.

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

Maximum number of ads to return across all queries.

## `enrichWithDetailPage` (type: `boolean`):

When true, fetches each ad's detail page (/ad-library/detail/{id}) to enrich records with `paid_for_by` (DSA disclosure), canonical `advertiser_url`, and any longer body copy. Adds ~0.5-1 s per ad. Note: impressions and targeting facets are loaded via XHR after render and are NOT extractable without a full browser session, so they remain unavailable.

## `proxy` (type: `object`):

Optional proxy. The LinkedIn Ad Library is fully public and works from datacenter IPs, so the default Apify Proxy is enabled but no residential group is required.

## Actor input object example

```json
{
  "searchTerms": [
    "AI",
    "remote work"
  ],
  "advertisers": [
    "Microsoft",
    "Anthropic"
  ],
  "countries": [],
  "dateOption": "last-30-days",
  "directUrls": [
    {
      "url": "https://www.linkedin.com/ad-library/search?keyword=AI"
    }
  ],
  "maxResults": 3,
  "enrichWithDetailPage": false,
  "proxy": {
    "useApifyProxy": 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 = {
    "maxResults": 3,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/linkedin-ads-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 = {
    "maxResults": 3,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/linkedin-ads-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 '{
  "maxResults": 3,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/linkedin-ads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Ads Scraper",
        "description": "Extract ads from the public LinkedIn Ad Library by keyword, advertiser, country, and date range. Returns headline, body, advertiser info, media URLs, impressions, targeting, and dates. No login required.",
        "version": "0.1",
        "x-build-id": "gVJf7iPVernV8nO2q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~linkedin-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-linkedin-ads-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/crawlerbros~linkedin-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-linkedin-ads-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/crawlerbros~linkedin-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-linkedin-ads-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keyword search queries (e.g., 'AI', 'cloud computing'). The Ad Library matches ads whose copy or advertiser contains any of these terms.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "advertisers": {
                        "title": "Advertisers",
                        "type": "array",
                        "description": "Advertiser / company names to search (e.g., 'Microsoft', 'Salesforce'). LinkedIn matches the advertiser display name.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "ISO-3166-1 alpha-2 country codes (e.g., 'US', 'GB', 'IN'). Filters ads to those served in the selected countries.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "dateOption": {
                        "title": "Date Range",
                        "enum": [
                            "last-30-days",
                            "last-90-days",
                            "last-year",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Pre-defined date window. Use 'custom' to specify exact dateFrom/dateTo.",
                        "default": "last-30-days"
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Start date for custom range (YYYY-MM-DD). Only used when dateOption=custom."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "End date for custom range (YYYY-MM-DD). Only used when dateOption=custom."
                    },
                    "directUrls": {
                        "title": "Direct URLs",
                        "type": "array",
                        "description": "Pre-built LinkedIn Ad Library URLs. Use this if you've already configured filters on linkedin.com/ad-library and just want to paste the URL.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of ads to return across all queries.",
                        "default": 50
                    },
                    "enrichWithDetailPage": {
                        "title": "Enrich With Detail Page",
                        "type": "boolean",
                        "description": "When true, fetches each ad's detail page (/ad-library/detail/{id}) to enrich records with `paid_for_by` (DSA disclosure), canonical `advertiser_url`, and any longer body copy. Adds ~0.5-1 s per ad. Note: impressions and targeting facets are loaded via XHR after render and are NOT extractable without a full browser session, so they remain unavailable.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy. The LinkedIn Ad Library is fully public and works from datacenter IPs, so the default Apify Proxy is enabled but no residential group is required.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```