# LinkedIn Ads Library Scraper · No Cookies · $1.50/1k ✅ (`linkedintel/linkedin-ads-library-scraper-no-cookies`) Actor

Extract ads from LinkedIn's public Ad Library. Search by company, keyword, or company ID. Returns creative, headline, CTA, landing URL, targeting, impressions per ad. No cookies, no login. $1.50/1k pay-per-result.

- **URL**: https://apify.com/linkedintel/linkedin-ads-library-scraper-no-cookies.md
- **Developed by:** [LinkedIntel](https://apify.com/linkedintel) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 ad extracteds

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 Ads Library Scraper — Extract every public LinkedIn ad

Extract ads from **LinkedIn's public Ad Library** — full creative, headlines, CTAs, landing URLs, targeting, impressions, run dates. Search by **company**, **keyword**, or **company ID**. Filter by country and date range. Clean structured JSON output. **No LinkedIn login, no cookies, no browser session, no account ban risk.**

Built for **B2B competitive intelligence, ad creative swipe files, ABM market research, brand monitoring, and marketing-due-diligence at scale**.

---

### How this compares to other LinkedIn Ads Library scrapers

We benchmarked the 14+ direct competitors on Apify Store. Here's the honest landscape:

| | automation-lab/linkedin-ad-library | silva95gustavo/linkedin-ad-library | scrapestorm/linkedin-ads-scraper | bebity/linkedin-premium-actor | **This actor** |
|---|---|---|---|---|---|
| **Pricing** | $1.15/1k + $0.005 start fee | Pay-per-result varies | $9.90/month rental | $29/month rental | **$1.50/1k flat** |
| **Search by company name** | ✅ | ✅ | ✅ | ✅ | ✅ |
| **Search by keyword** | ✅ | Partial | ✅ | ❌ | ✅ |
| **Search by LinkedIn company ID** | Partial | ❌ | ❌ | ❌ | ✅ |
| **Country filter** | ✅ | ✅ | ❌ | ❌ | ✅ |
| **Date range filter** | ✅ | ✅ | ❌ | ❌ | ✅ |
| **Impressions data per ad** | ✅ | ❌ | ✅ | Partial | ✅ |
| **Carousel image extraction** | ✅ | ❌ | Partial | Partial | ✅ |
| **No subscription gate** | ✅ | ✅ | ❌ | ❌ | ✅ |
| **No cookies / login** | ✅ | ✅ | ✅ | ❓ | ✅ |
| **Architecture** | Direct HTTP | Browser-based | Browser-based | Subscription rental | Managed vendor API |
| **Source code visibility** | Public | Public | Public | Public | **Hidden (paid-tier protection)** |

**Bottom line:** at **$1.50/1k flat pay-per-result, no subscription, no per-run fees**, this is the most predictable cost in the LinkedIn Ad Library niche. Crowded category — we differentiate on (1) full search-parameter coverage (company + companyId + keyword + countries + dates), (2) impressions + targeting + carousel data, (3) source-code-hidden architecture protection.

### What you get — 1 record per ad

For each search query (per company / keyword / companyId), the actor paginates through all matching ads and emits one `linkedinAd` record per ad.

#### `linkedinAd` record (24 fields)
- **Identification**: `adId`, `adDetailUrl` (LinkedIn Ad Library detail link), `adType` (e.g., "Single Image Ad", "Video Ad", "Carousel Ad")
- **Advertiser**: `advertiser`, `advertiserLinkedinPage`, `poster`, `posterTitle`, `promotedBy`
- **Creative**: `headline`, `description`, `cta`, `destinationUrl`, `imageUrl`, `videoUrl`, `carouselImages`
- **Targeting**: `targetingLanguage`, `targetingLocation`, `targetingAudience`
- **Run period**: `adDuration` (human-readable), `startDateIso`, `endDateIso`
- **Reach**: `totalImpressions` (e.g., "5k-10k"), `impressionsByCountry`
- **Search context**: `searchCompany`, `searchKeyword`, `searchCompanyId`, `searchCountries`, `searchStartDate`, `searchEndDate`
- **Tracking**: `sourceInput`, `scrapedAt`

Plus `diagnostic` (1 per search with no results) and `summary` (1 per run, non-billable).

### Use cases (top 7)

#### 1. Competitive ad-creative analysis — what's working in your category
Feed your top 5 competitors' company names. Get every ad they've run with full creative, headline, and CTA copy. Build a swipe file. Track what they iterate on.

#### 2. Sales enablement — show your customer how their competitors advertise
Use during sales discovery: pull a prospect's competitors' ads, present at the demo. "Here's what your competitors are saying — here's how we help you win."

#### 3. ABM intelligence — track named-account marketing spend signals
For your top 100 target accounts, run a monthly cron. New ads = active marketing investment = better timing for outreach.

#### 4. Brand monitoring — what's said about your category
Set up keyword searches for your category (`"AI agents"`, `"CDP"`, `"customer success"`). Track who's spending against the topic.

#### 5. Market entry research
Filter by country (`["DE", "FR", "ES"]`) + keyword to see which advertisers are dominant in a target geography. Map the competitive landscape before launching.

#### 6. Creative swipe file at scale
Pull thousands of ads filtered by industry, build a searchable internal database. Designers and copywriters can reference what's resonating.

#### 7. Investment due diligence on B2B SaaS
Active ad spend is a leading indicator of company health. For investment targets, pull 90-day ad activity history (`startDate` filter) to validate growth claims.

### How it works

1. Provide one or more of: `companyNames` (array), `companyIds` (array), `keywords` (array). Each value triggers a separate search.
2. Optional filters: `countries` (array of ISO codes), `startDate`/`endDate` (YYYY-MM-DD).
3. Set `maxAdsPerSearch` (1-1000, default 100).
4. The actor paginates LinkedIn's Ad Library via a managed vendor partnership — no browser, no cookies, no IP rotation needed on your end.

No login required. No cookies. Cookieless via managed vendor partnership — no account ban risk on your side, no session management.

### Example input

```json
{
  "companyNames": ["Microsoft", "Salesforce", "Adobe"],
  "keywords": ["AI", "customer success"],
  "countries": ["US", "GB"],
  "startDate": "2025-01-01",
  "maxAdsPerSearch": 200
}
````

This run executes 5 searches (3 companies + 2 keywords), each capped at 200 ads. Estimated max output: 1,000 ad records.

### Pricing — pay only for ads returned

**$1.50 per 1,000 ads. Pay-per-result.**

- ✅ No subscription
- ✅ No monthly minimum
- ✅ No per-run start fee
- ✅ No charge for searches that return zero ads (clean diagnostic record)
- ✅ Apify's free tier ($5/month platform credit) covers ~3,300 ads to start

**Cost comparison for 10,000 LinkedIn ads:**

| Provider | 10K ad cost | Notes |
|---|---|---|
| scrapestorm/linkedin-ads-scraper (rental) | $9.90/mo subscription | + usage |
| bebity/linkedin-premium-actor (rental) | $29/mo subscription | + usage |
| automation-lab/linkedin-ad-library | $11.50 + start fees | Lowest per-result floor |
| **This actor** | **$15.00** flat, no fees | Predictable; pay-per-result only |

We're not the absolute cheapest per-ad — we're the most **predictable**. No surprise per-run fees, no subscriptions, no rental gates. What you see is what you pay.

### Combine with other LinkedIn actors

Build a complete LinkedIn marketing-intelligence pipeline:

- Feed `advertiserLinkedinPage` from this actor into the **LinkedIn Company Scraper** → full firmographics on the advertiser
- Feed `advertiser` company name into the **LinkedIn Company Employees Scraper** → find the marketing team to outreach
- Feed `searchKeyword` (your category) into the **LinkedIn Search Scraper** → find people discussing the topic publicly
- Feed `advertiser` into the **LinkedIn Post Scraper** → see their organic content alongside their paid content (full content strategy view)

### FAQ

**Q: How fresh is the data?**
Real-time from LinkedIn's public Ad Library. Each query hits LinkedIn's current data at scrape time. Re-run anytime to refresh.

**Q: Does LinkedIn Ad Library cover all ads, or just political ones?**
All ads. LinkedIn's Ad Library is a transparency tool for ALL ads on LinkedIn (B2B-focused), including: sponsored content, message ads, single-image, video, carousel, document, event ads, dynamic ads, follower ads, thought-leader ads.

**Q: Can I get the actual click-through rate / CPC / CPM?**
No — those are internal advertiser metrics. LinkedIn only exposes `totalImpressions` (banded like "5k-10k") and ad duration publicly.

**Q: What if a search returns 0 results?**
The actor emits a single `diagnostic` record explaining the empty result. You aren't charged for ads not returned.

**Q: How many ads can I get per search?**
Hard cap is 1,000 per `maxAdsPerSearch`. The LinkedIn Ad Library itself contains millions of ads — narrow your search by date or country to get the slice you care about.

**Q: Does this work for B2C ads?**
LinkedIn Ads Library is primarily B2B (LinkedIn's user base). You won't find consumer brands here unless they're running B2B campaigns (e.g., recruiting, partnerships).

**Q: Can I scrape ads from the EU's special political-ads section?**
Yes — political ads appear in the same search results when relevant. The `totalImpressions` and targeting transparency are mandated for political ads (DSA / EU).

**Q: Is this safe to use vs my LinkedIn account?**
Yes. No login, no cookies. The actor never authenticates as you.

### Privacy & compliance

This actor scrapes **publicly accessible LinkedIn Ad Library content** — the same data any logged-out visitor can browse at linkedin.com/ad-library/. The Ad Library exists by design as a transparency tool.

Advertiser data (name, page) is public. Targeting and impressions are bucketed (e.g., "5k-10k") for privacy. Customers are responsible for compliance with applicable laws when using scraped data (GDPR, CCPA, copyright on creative assets).

Not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation.

# Actor input Schema

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

List of advertiser/company names to search for in the LinkedIn Ad Library. Each name triggers a separate search.

## `companyIds` (type: `array`):

Optional. LinkedIn company IDs (numeric, e.g. 1035 = Microsoft) to filter ads by specific advertisers.

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

Keywords to search for in ad text/headlines. Each keyword triggers a separate search.

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

ISO 3166-1 alpha-2 country codes to filter ads by geography (e.g., 'US', 'GB', 'DE'). Comma-separated string or array.

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

Only return ads that started running on or after this date. Format: YYYY-MM-DD.

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

Only return ads that started running on or before this date. Format: YYYY-MM-DD.

## `maxAdsPerSearch` (type: `integer`):

Hard cap on ads returned per search query (per company name, per company ID, per keyword).

## Actor input object example

```json
{
  "companyNames": [
    "Microsoft"
  ],
  "countries": [],
  "maxAdsPerSearch": 100
}
```

# 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": [
        "Microsoft"
    ],
    "countries": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/linkedin-ads-library-scraper-no-cookies").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": ["Microsoft"],
    "countries": [],
}

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/linkedin-ads-library-scraper-no-cookies").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": [
    "Microsoft"
  ],
  "countries": []
}' |
apify call linkedintel/linkedin-ads-library-scraper-no-cookies --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Ads Library Scraper · No Cookies · $1.50/1k ✅",
        "description": "Extract ads from LinkedIn's public Ad Library. Search by company, keyword, or company ID. Returns creative, headline, CTA, landing URL, targeting, impressions per ad. No cookies, no login. $1.50/1k pay-per-result.",
        "version": "1.0",
        "x-build-id": "GoMatoYbfrhfKpblw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-ads-library-scraper-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-linkedin-ads-library-scraper-no-cookies",
                "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/linkedintel~linkedin-ads-library-scraper-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-linkedin-ads-library-scraper-no-cookies",
                "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/linkedintel~linkedin-ads-library-scraper-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-linkedin-ads-library-scraper-no-cookies",
                "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 names",
                        "type": "array",
                        "description": "List of advertiser/company names to search for in the LinkedIn Ad Library. Each name triggers a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyIds": {
                        "title": "Company IDs (numeric)",
                        "type": "array",
                        "description": "Optional. LinkedIn company IDs (numeric, e.g. 1035 = Microsoft) to filter ads by specific advertisers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Keywords to search for in ad text/headlines. Each keyword triggers a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countries": {
                        "title": "Countries filter (optional)",
                        "type": "array",
                        "description": "ISO 3166-1 alpha-2 country codes to filter ads by geography (e.g., 'US', 'GB', 'DE'). Comma-separated string or array.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date (optional)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only return ads that started running on or after this date. Format: YYYY-MM-DD."
                    },
                    "endDate": {
                        "title": "End date (optional)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only return ads that started running on or before this date. Format: YYYY-MM-DD."
                    },
                    "maxAdsPerSearch": {
                        "title": "Max ads per search",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on ads returned per search query (per company name, per company ID, per keyword).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```