# LinkedIn Ad Library Multi-Search Scraper (`jy-labs/linkedin-ad-library-multi-search-scraper`) Actor

Search the public LinkedIn Ad Library across multiple companies, ad text keywords, and payer names. Collect ad creatives in fast mode or add public transparency, impression, targeting, and landing-page fields in full mode.

- **URL**: https://apify.com/jy-labs/linkedin-ad-library-multi-search-scraper.md
- **Developed by:** [Juyeop Park](https://apify.com/jy-labs) (community)
- **Categories:** Marketing, Social media, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 fast ad 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Ad Library Multi-Search Scraper

> This is an independent, unofficial tool. It is not affiliated with, endorsed by, or sponsored by LinkedIn. It only reads information exposed by the public LinkedIn Ad Library and does not accept LinkedIn credentials, cookies, or member data.

Search multiple company names, ad text keywords, and payer names in one run. Results from every search are merged by LinkedIn ad ID, while the `matches` field preserves exactly which searches found each ad.

Use Fast mode for affordable creative research or Full mode when you need the
public transparency fields LinkedIn exposes on individual ad pages.

### What it collects

- Advertiser name, company ID and public company URL
- Ad format, text, headline, CTA, creatives, and source URL
- Every matching company, keyword, or payer search with its rank
- `full` mode: public payer name, run period, landing URL, impression range, country breakdown, and targeting
- Restricted ads as explicit rows without inventing hidden values

The Actor does not scrape LinkedIn profiles, emails, contacts, or logged-in content.

### Input

Provide at least one value in `companyNames`, `keywords`, or `payerNames`. Across the three lists, you can submit up to 20 unique searches.

```json
{
    "companyNames": ["HubSpot", "Salesforce", "Monday.com"],
    "keywords": ["CRM", "AI agent"],
    "countries": ["US", "GB", "DE"],
    "dateOption": "last-30-days",
    "detailMode": "fast",
    "maxResultsPerSearch": 25,
    "maxTotalResults": 100
}
````

#### Date filters

Choose `last-30-days`, `current-month`, `current-year`, `last-year`, or `custom-date-range`. A custom range requires both dates, must stay within the most recent year, and must end no later than the previous UTC day because LinkedIn only exposes completed days.

```json
{
    "keywords": ["cybersecurity"],
    "countries": ["FR", "DE"],
    "dateOption": "custom-date-range",
    "startDate": "2026-07-01",
    "endDate": "2026-07-23",
    "detailMode": "full"
}
```

`ALL` must be used by itself. Otherwise, use up to five ISO two-letter country codes.

### Fast and Full modes

`fast` mode returns fields visible on search cards and is the best choice for
creative discovery and competitor monitoring. It costs **$0.001 per saved
result**.

`full` mode opens each public ad detail page and costs **$0.002 per saved
result**. LinkedIn only exposes some transparency fields for eligible ads and
regions. Missing non-EU transparency data is returned as `null` and is not
considered an error. If a detail page fails, the search-card result is retained
with `detailStatus: "failed"`.

### Output

Each Dataset row represents one unique ad ID:

```json
{
    "adId": "1455310303",
    "matches": [
        {
            "type": "company",
            "value": "JetBrains",
            "rank": 1,
            "countries": ["FR", "DE"],
            "searchUrl": "https://www.linkedin.com/ad-library/search?accountOwner=JetBrains"
        }
    ],
    "advertiser": {
        "name": "JetBrains",
        "companyId": "12515",
        "companyUrl": "https://www.linkedin.com/company/12515",
        "logoUrl": "https://media.licdn.com/..."
    },
    "payerName": "JetBrains s.r.o.",
    "adFormat": "Single Image Ad",
    "adText": "Build better software.",
    "headline": "Try IntelliJ IDEA",
    "ctaLabel": "Learn more",
    "landingUrl": "https://www.jetbrains.com/idea/",
    "creatives": [
        {
            "type": "image",
            "url": "https://media.licdn.com/...",
            "thumbnailUrl": null
        }
    ],
    "runPeriod": {
        "startDate": "2026-07-22",
        "endDate": "2026-07-23"
    },
    "restricted": false,
    "impressions": {
        "display": "30k-50k",
        "min": 30000,
        "max": 50000,
        "byCountry": [{ "country": "France", "percentage": 60 }]
    },
    "targeting": [
        {
            "category": "Location",
            "included": ["France", "Germany"],
            "excluded": []
        }
    ],
    "detailStatus": "complete",
    "retrievalMode": "http",
    "sourceUrl": "https://www.linkedin.com/ad-library/detail/1455310303",
    "scrapedAt": "2026-07-24T00:00:00.000Z"
}
```

The default Key-Value Store record `SUMMARY` contains search-level statuses, raw and deduplicated counts, confirmed empty searches, partial results, browser fallbacks, bounded error messages, final output count, and billing-limit state. Summary data is never mixed into the Dataset.

### Empty results and blocking

An HTTP page is considered empty only when LinkedIn shows an explicit empty-result message. A 403, 429, error shell, meaningless 404, or page without both ads and empty-result evidence is treated as blocking or a parse failure.

HTTP requests retry twice with a new session. Independent HTTP searches run
with a maximum concurrency of five. If a search still fails, only that search
is reprocessed in a browser, with at most two browser fallbacks at once. A run
succeeds partially when at least one search succeeds. It fails only when every
search is blocked or unparsable; an all-empty run succeeds normally.

### Pricing

| Charge            |                           Price |
| ----------------- | ------------------------------: |
| Fast saved result |                          $0.001 |
| Full saved result |                          $0.002 |
| Actor start event | $0.00005 per charged start unit |

That is **$1 per 1,000 Fast results** or **$2 per 1,000 Full results**, plus the
small start event. Apify automatically scales the synthetic start-event count
with allocated memory; at the default 1 GB, a run charges one start unit for a
total of `$0.00005`. The start event also makes the first five seconds of
compute eligible for Apify's PPE startup coverage.

The minimum maximum charge is `$0.0022`, which supports a default-memory start,
one Full result, and a small safety margin. Set a higher maximum charge when
requesting more results.

Before Full detail work, the Actor checks how many `full-ad-result` events still
fit within the user's limit. Fast mode checks `fast-ad-result` instead. Each row
is validated, saved, and charged together. When another result cannot be
charged, the Actor stops and records `chargeLimitReached: true` in `SUMMARY`.

Result estimate:

```text
Fast = unique saved results × $0.001
Full = unique saved results × $0.002
Default-memory start = $0.00005
```

`SUMMARY.pricing` records the observed Fast, Full, and start prices and whether
they match the release contract. Production runs refuse to start when the
deployed PPE configuration differs from this contract, preventing accidental
misbilling.

### Run through the API

Run and wait for Dataset output with an Apify API token in the authorization
header:

```bash
curl --request POST \
  "https://api.apify.com/v2/acts/jy-labs~linkedin-ad-library-multi-search-scraper/run-sync-get-dataset-items?format=json&clean=true" \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "companyNames": ["HubSpot", "Salesforce"],
    "countries": ["US", "DE"],
    "detailMode": "fast",
    "maxResultsPerSearch": 10,
    "maxTotalResults": 20
  }'
```

For larger runs, start the Actor asynchronously with `/runs`, then read the
default Dataset and the `SUMMARY` record using the storage IDs returned by the
run.

### Common use cases

- Compare LinkedIn ads from multiple competitors
- Search B2B categories such as CRM, cybersecurity, or AI agents
- Find ads by the disclosed payer entity
- Inspect public EU impression and targeting transparency
- Compare creative strategies across countries

### FAQ and troubleshooting

#### Why did a successful search return zero rows?

`confirmed_no_results` means LinkedIn explicitly showed that no ads matched the
filters. Broaden the date range, use `ALL`, or try the advertiser's exact public
name. A blocked or ambiguous page is never reported as an empty result.

#### Why are impressions or targeting `null`?

LinkedIn exposes these fields only for eligible ads and regions. Use Full mode
and include relevant European countries. Missing public transparency data is
represented as `null`; the Actor does not infer it.

#### What does `completed_partial` mean?

At least one search succeeded, but another search, pagination page, or detail
page was unavailable. Review `SUMMARY.searches`, `detailErrors`, and
`browserFallbackSearches`. Successfully collected card rows remain in the
Dataset.

#### Why did output stop before `maxTotalResults`?

The run's maximum charge may not allow another result. Increase the maximum
charge and rerun. `SUMMARY.chargeLimitReached` distinguishes this from search
limits or deduplication.

#### Does the Actor require a LinkedIn account?

No. It accepts no LinkedIn login, cookie, or member data and reads only the
public Ad Library.

### Responsible use

You are responsible for using the output in accordance with applicable laws, LinkedIn's current terms, robots policies, and Apify's platform rules. Public web content can change without notice. Before Store publication, the latest relevant policies must be reviewed; if publication is not permitted, keep the Actor private.

# Actor input Schema

## `companyNames` (type: `array`):

Company or advertiser names to search. You can combine these with keyword and payer searches, up to 20 unique searches in total.

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

Keywords to search in public LinkedIn ads.

## `payerNames` (type: `array`):

Names shown in LinkedIn's “Paid for by” transparency field.

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

Up to five two-letter country codes. Use ALL by itself to search all countries.

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

Select a LinkedIn date preset or choose a custom range within the last year. LinkedIn accepts completed UTC days only.

## `startDate` (type: `string`):

Required with a custom date range. Use YYYY-MM-DD and stay within the most recent year.

## `endDate` (type: `string`):

Required with a custom date range. Use YYYY-MM-DD and choose no later than the previous UTC day.

## `detailMode` (type: `string`):

Fast ($1 per 1,000 results) collects search cards. Full ($2 per 1,000 results) also opens each detail page for payer, run period, public impressions, targeting, and landing URL.

## `maxResultsPerSearch` (type: `integer`):

Maximum unique ads collected for each company, keyword, or payer search.

## `maxTotalResults` (type: `integer`):

Maximum unique ads returned and billed after merging duplicates across all searches.

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

Optional proxy settings. The scraper rotates sessions on HTTP blocking and can fall back to a browser.

## `requestTimeoutSecs` (type: `integer`):

Maximum time for each HTTP or browser navigation, in seconds.

## `debugMode` (type: `boolean`):

Enable additional operational logs. Cookies, tokens, and page HTML are never logged.

## Actor input object example

```json
{
  "companyNames": [
    "JetBrains",
    "HubSpot"
  ],
  "countries": [
    "US",
    "DE"
  ],
  "dateOption": "last-30-days",
  "detailMode": "fast",
  "maxResultsPerSearch": 10,
  "maxTotalResults": 50,
  "requestTimeoutSecs": 45,
  "debugMode": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `creatives` (type: `string`):

No description

## `transparency` (type: `string`):

No description

## `summary` (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 = {
    "companyNames": [
        "JetBrains",
        "HubSpot"
    ],
    "countries": [
        "US",
        "DE"
    ],
    "maxResultsPerSearch": 10,
    "maxTotalResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("jy-labs/linkedin-ad-library-multi-search-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 = {
    "companyNames": [
        "JetBrains",
        "HubSpot",
    ],
    "countries": [
        "US",
        "DE",
    ],
    "maxResultsPerSearch": 10,
    "maxTotalResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("jy-labs/linkedin-ad-library-multi-search-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 '{
  "companyNames": [
    "JetBrains",
    "HubSpot"
  ],
  "countries": [
    "US",
    "DE"
  ],
  "maxResultsPerSearch": 10,
  "maxTotalResults": 50
}' |
apify call jy-labs/linkedin-ad-library-multi-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Ad Library Multi-Search Scraper",
        "description": "Search the public LinkedIn Ad Library across multiple companies, ad text keywords, and payer names. Collect ad creatives in fast mode or add public transparency, impression, targeting, and landing-page fields in full mode.",
        "version": "0.1",
        "x-build-id": "FtzoO5xw4CClnbPKk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jy-labs~linkedin-ad-library-multi-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jy-labs-linkedin-ad-library-multi-search-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/jy-labs~linkedin-ad-library-multi-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jy-labs-linkedin-ad-library-multi-search-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/jy-labs~linkedin-ad-library-multi-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jy-labs-linkedin-ad-library-multi-search-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": {
                    "companyNames": {
                        "title": "Company or advertiser names",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Company or advertiser names to search. You can combine these with keyword and payer searches, up to 20 unique searches in total.",
                        "items": {
                            "type": "string",
                            "maxLength": 500
                        }
                    },
                    "keywords": {
                        "title": "Ad text keywords",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Keywords to search in public LinkedIn ads.",
                        "items": {
                            "type": "string",
                            "maxLength": 500
                        }
                    },
                    "payerNames": {
                        "title": "Payer names",
                        "maxItems": 20,
                        "type": "array",
                        "description": "Names shown in LinkedIn's “Paid for by” transparency field.",
                        "items": {
                            "type": "string",
                            "maxLength": 500
                        }
                    },
                    "countries": {
                        "title": "Countries",
                        "minItems": 1,
                        "maxItems": 5,
                        "type": "array",
                        "description": "Up to five two-letter country codes. Use ALL by itself to search all countries.",
                        "items": {
                            "type": "string",
                            "minLength": 2,
                            "maxLength": 3
                        },
                        "default": [
                            "ALL"
                        ]
                    },
                    "dateOption": {
                        "title": "Date range",
                        "enum": [
                            "last-30-days",
                            "current-month",
                            "current-year",
                            "last-year",
                            "custom-date-range"
                        ],
                        "type": "string",
                        "description": "Select a LinkedIn date preset or choose a custom range within the last year. LinkedIn accepts completed UTC days only.",
                        "default": "last-30-days"
                    },
                    "startDate": {
                        "title": "Custom start date",
                        "type": "string",
                        "description": "Required with a custom date range. Use YYYY-MM-DD and stay within the most recent year."
                    },
                    "endDate": {
                        "title": "Custom end date",
                        "type": "string",
                        "description": "Required with a custom date range. Use YYYY-MM-DD and choose no later than the previous UTC day."
                    },
                    "detailMode": {
                        "title": "Detail mode",
                        "enum": [
                            "fast",
                            "full"
                        ],
                        "type": "string",
                        "description": "Fast ($1 per 1,000 results) collects search cards. Full ($2 per 1,000 results) also opens each detail page for payer, run period, public impressions, targeting, and landing URL.",
                        "default": "fast"
                    },
                    "maxResultsPerSearch": {
                        "title": "Maximum results per search",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum unique ads collected for each company, keyword, or payer search.",
                        "default": 50
                    },
                    "maxTotalResults": {
                        "title": "Maximum total results",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum unique ads returned and billed after merging duplicates across all searches.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. The scraper rotates sessions on HTTP blocking and can fall back to a browser."
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 10,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time for each HTTP or browser navigation, in seconds.",
                        "default": 45
                    },
                    "debugMode": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable additional operational logs. Cookies, tokens, and page HTML are never logged.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```