# TikTok Ad Library Scraper — Ads, Creatives & Advertisers (`jaybird/tiktok-ad-library-scraper`) Actor

Scrape TikTok's Commercial Content Library into clean JSON. Search ads by advertiser or keyword and export creatives, run dates, audience bands, and EU targeting. $3.50 per 1,000 ads — no TikTok API approval needed.

- **URL**: https://apify.com/jaybird/tiktok-ad-library-scraper.md
- **Developed by:** [Jaybird Technologies](https://apify.com/jaybird) (community)
- **Categories:** Lead generation, Agents, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 tiktok ads

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

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

## What's an Apify Actor?

Actors are 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

## TikTok Ad Library Scraper

Scrape [TikTok's Commercial Content Library](https://library.tiktok.com/ads) into clean JSON without an account, cookies, or API approval. Search by advertiser or keyword, filter by country and date, and export ad creatives, run dates, audience bands, and — for every ad — TikTok's disclosed EU targeting and advertiser details.

- **$2.50 per 1,000 ads** (FREE tier), no monthly rental. Higher Apify plans pay less per ad.
- Covers ads served in the **EU/EEA**, where TikTok is required to publish ad transparency data.

```json
{
    "type": "ad",
    "adId": "1869604317380609",
    "advertiserName": "Zalando SE",
    "caption": "Vai su Zalando",
    "adFormat": "video",
    "videoUrl": "https://library.tiktok.com/api/v1/cdn/.../video.mp4",
    "coverImageUrl": "https://p16-common-sign.tiktokcdn.com/....image",
    "firstShownDate": "2026-07-18",
    "lastShownDate": "2026-07-18",
    "estimatedAudience": "100K-200K",
    "callToAction": "Shop now",
    "advertisingObjective": "Sales",
    "advertiserBusinessId": "6876456332912755458",
    "advertiserRegistryLocation": "Germany",
    "sponsor": "Zalando SE",
    "totalImpressions": "200K-300K",
    "impressionsByCountry": [{ "country": "IT", "impressions": "204K" }],
    "targeting": {
        "countries": ["IT"],
        "ageRanges": ["18-24", "25-34", "35-44", "45-54", "55+"],
        "genders": ["female", "male"],
        "targetAudienceSize": "20.8M-25.4M",
        "operatingSystems": ["ANDROID"]
    },
    "adDetailUrl": "https://library.tiktok.com/ads/detail/?ad_id=1869604317380609&region=all",
    "query": "Zalando",
    "queryType": "advertiser"
}
````

### What does it do?

- **Advertiser search** — pass a list of advertiser names. Results are filtered to that advertiser's own ads, so you get Zalando's ads rather than every creator who mentioned Zalando.
- **Keyword search** — free-text search across ad content and advertiser names.
- **Targeting & advertiser enrichment** — on by default, it pulls each ad's call to action, objective, advertiser business ID and registered country, audience-size estimate, and full targeting (countries, age bands, gender, languages, impressions by country). Turn it off for a faster, card-only run.

### Why use this scraper?

- 💰 **Flat, low price:** $2.50 per 1,000 ads with full targeting enrichment included — no separate "detail" fee, and the same ad across two searches is never charged twice. No monthly fee.
- 🎯 **Real EU targeting data:** age bands, gender, audience size, and per-country impressions that TikTok discloses under its transparency obligations — most scrapers stop at the creative.
- 🔍 **Clean advertiser results:** advertiser searches are matched to the advertiser's own ads, not TikTok's loose fuzzy matches.
- 🎬 **Full creatives:** direct video and cover-image URLs, caption, format, and run dates.
- 🚫 **No account, no login:** touches only TikTok's public transparency API. It never asks for or uses credentials.
- 🗂️ **Honest completeness:** the run summary distinguishes true zero-result searches from blocked or incomplete work.

### What data can it extract?

| Field | Description |
|---|---|
| `adId` | TikTok's unique ad ID |
| `advertiserName` | Advertiser account that ran the ad |
| `caption` | Ad caption / creative text, when shown |
| `adFormat` | `video`, `image`, or `unknown` |
| `videoUrl`, `coverImageUrl`, `imageUrls` | Creative media (signed CDN URLs — see FAQ) |
| `firstShownDate`, `lastShownDate` | Run dates (ISO `YYYY-MM-DD`) |
| `estimatedAudience` | Audience band ("unique users seen"), e.g. `10K-100K` |
| `callToAction`, `advertisingObjective` | CTA label and campaign objective (enrichment) |
| `advertiserBusinessId`, `advertiserRegistryLocation`, `sponsor` | Advertiser identity and paying entity (enrichment) |
| `totalImpressions`, `impressionsByCountry` | Disclosed impression bands (enrichment) |
| `targeting` | Countries, age bands, gender, audience size, languages, OS (enrichment) |
| `adDetailUrl` | Permalink to the ad in the public library |
| `query`, `queryType`, `region`, `scrapedAt` | Provenance for each row |

The default dataset contains ads only, so JSON, CSV, and Excel exports stay homogeneous. A separate `OUTPUT` key-value record holds one summary per search (`totalAdsFound`, `adsScraped`, date range covered) plus aggregate run health.

### How to scrape the TikTok Ad Library

1. Add one or more advertiser names to **Advertisers**, and/or a **Keyword**.
2. Optionally scope by **Target countries** (EU/EEA ISO codes) and a **date range**.
3. Leave **Include targeting & advertiser details** on for full data, or turn it off for a faster, cheaper card-only run.
4. Set **Max ads per search** and run. Export the dataset as JSON, CSV, or Excel, or pull it via the Apify API.

### How much will it cost?

Pay-per-event: **$0.0025 per ad scraped — $2.50 per 1,000 ads** at the FREE tier, no monthly rental, and targeting enrichment is included in the same price. Example: monitoring 10 advertisers at up to 100 ads each costs at most **$2.50 per run**. Billing is once per unique ad, so duplicates across searches are free. Higher Apify pricing tiers receive lower per-ad rates, and the **Pricing** tab is authoritative for the live rates.

### Input example

```json
{
    "advertisers": ["Zalando", "About You"],
    "keyword": "summer sale",
    "countries": ["DE", "FR"],
    "startDate": "2026-01-01",
    "endDate": "2026-07-01",
    "includeTargeting": true,
    "maxResultsPerQuery": 100
}
```

If no advertiser or keyword is supplied, the platform auto-test runs a small demo search capped at ten ads.

### Output example

The `OUTPUT` key-value record holds diagnostics and one summary per search:

```json
{
    "summaries": [
        {
            "type": "advertiser-summary",
            "query": "Zalando",
            "queryType": "advertiser",
            "region": "all",
            "totalAdsFound": 1000,
            "adsScraped": 100,
            "enrichmentFailures": 0,
            "blocked": false,
            "incomplete": false
        }
    ],
    "queries": 1,
    "adsScraped": 100,
    "escalatedToResidential": 0,
    "chargeLimitReached": false,
    "charged": { "ad-scraped": 100 },
    "includeTargeting": true,
    "demoMode": false
}
```

`totalAdsFound` is TikTok's own reported match estimate (capped at ~1,000); `adsScraped` is how many ads were actually stored after filtering. Local and non-pay-per-event runs report zero charged events even though they still write the dataset.

### How it works

TikTok's Commercial Content Library is backed by a public JSON API — no login, no headless browser, no request signing. The Actor fetches a short-lived session token, then paginates the search endpoint and (when enrichment is on) requests each ad's detail record. Requests run on datacenter proxies and escalate to residential proxies if TikTok's rate limiter ("system busy") starts pushing back. There is no logged-in mode: the Actor only reads TikTok's public advertising-transparency surface.

### EU/EEA scope — read this first

The Commercial Content Library only covers **ads served in the EU/EEA**, which TikTok is required to publish under its transparency obligations. Ads shown only outside that region are not in the source and cannot be returned, regardless of the countries you request. This is a scope of the data itself, not a limitation of the Actor. (A future update may add TikTok Creative Center "Top Ads" as a separate, global complement.)

### FAQ

**Is there an official TikTok ads API?** TikTok offers a Commercial Content Library "research API," but it is gated behind an application and approval process. This Actor uses the same public data that powers the library's own website, with no approval needed.

**How exact is advertiser matching?** TikTok's search matches loosely, so a raw search for "Zalando" also surfaces unrelated handles that merely share a fragment. Advertiser searches filter results to ads whose advertiser name actually matches your query; use a **Keyword** search when you want the full loose match across ad content.

**Why is `totalAdsFound` always around 1,000?** That number is TikTok's own capped match estimate, not an exact count. Rely on `adsScraped` for what was actually stored.

**Do the video and image URLs last?** No. TikTok serves creatives from signed CDN URLs that expire after a short time. Download the media promptly rather than storing the URL for later.

**Why do some ads have empty targeting?** Targeting, impressions, and objective come from each ad's detail record and are only disclosed for EU/EEA-served ads. When enrichment is off, those fields are intentionally left null.

**How does it handle blocking?** TikTok answers "system busy" (HTTP 421) when an IP calls too fast. The Actor backs off, rotates proxy sessions, and escalates datacenter → residential. Genuinely blocked searches are reported in the run summary instead of being silently dropped.

**Is it legal to scrape the Ad Library?** The Actor collects public advertising-transparency data that TikTok is legally required to publish — no personal accounts, no logins, no private data. You remain responsible for lawful use of the output, including any GDPR obligations that apply to how you store and process it.

**Can I schedule or integrate it?** Yes. Export to Google Sheets, Drive, S3, or a database; use Zapier, Make, webhooks, schedules, or the Apify API.

***

Monitoring competitors across channels? See the [Meta Ad Library Scraper](https://apify.com/jaybird/meta-ad-library-scraper), [Google Ads Transparency Scraper](https://apify.com/jaybird/google-ads-transparency-scraper), and [LinkedIn Ad Library Scraper](https://apify.com/jaybird/linkedin-ad-library-scraper) — one workflow across TikTok, Meta, Google, and LinkedIn.

The Actor collects public advertising-transparency data only. You remain responsible for lawful use of the output.

# Actor input Schema

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

Advertiser names to search, e.g. \["Zalando", "About You"]. Each entry becomes its own search. TikTok matches names loosely, so a search for "Zalando" can also return other advertisers whose ads mention it — every result carries `advertiserName` so you can filter exactly.

## `keyword` (type: `string`):

Free-text search across ad content and advertiser names. Runs as its own search in addition to any advertisers above.

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

Two-letter ISO 3166-1 codes of EU/EEA countries to scope the search, e.g. \["DE", "FR"]. Each country runs as a separate search. Leave empty to search all covered countries at once (recommended).

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

Only return ads shown on or after this date (YYYY-MM-DD). Defaults to one year ago. TikTok retains Commercial Content Library ads for one year.

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

Only return ads shown on or before this date (YYYY-MM-DD). Defaults to today.

## `includeTargeting` (type: `boolean`):

Fetch each ad's detail page for the call to action, advertising objective, advertiser business ID and registry country, audience-size estimate, and full targeting breakdown (countries, age bands, gender, languages, impressions by country). Turning this off is faster but returns card-level fields only. Billed the same either way.

## `maxResultsPerQuery` (type: `integer`):

Cap on stored ads per advertiser or keyword search (per country). Each stored ad emits exactly one billing event. Raise the run timeout in Run options for large caps — TikTok rate-limits heavy scraping, so big runs take longer than the 5-minute default.

## Actor input object example

```json
{
  "advertisers": [
    "Zalando"
  ],
  "keyword": "summer sale",
  "countries": [
    "DE",
    "FR"
  ],
  "startDate": "2026-01-01",
  "endDate": "2026-07-01",
  "includeTargeting": true,
  "maxResultsPerQuery": 20
}
```

# Actor output Schema

## `ads` (type: `string`):

Default dataset containing one homogeneous record per scraped ad.

## `summary` (type: `string`):

Per-search summaries, request health, and confirmed billing-event counts from the OUTPUT record.

# 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 = {
    "advertisers": [
        "Zalando"
    ],
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("jaybird/tiktok-ad-library-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 = {
    "advertisers": ["Zalando"],
    "maxResultsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("jaybird/tiktok-ad-library-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 '{
  "advertisers": [
    "Zalando"
  ],
  "maxResultsPerQuery": 20
}' |
apify call jaybird/tiktok-ad-library-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TikTok Ad Library Scraper — Ads, Creatives & Advertisers",
        "description": "Scrape TikTok's Commercial Content Library into clean JSON. Search ads by advertiser or keyword and export creatives, run dates, audience bands, and EU targeting. $3.50 per 1,000 ads — no TikTok API approval needed.",
        "version": "0.1",
        "x-build-id": "Q4YRr93hsP257IwS9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jaybird~tiktok-ad-library-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jaybird-tiktok-ad-library-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/jaybird~tiktok-ad-library-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jaybird-tiktok-ad-library-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/jaybird~tiktok-ad-library-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jaybird-tiktok-ad-library-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": {
                    "advertisers": {
                        "title": "Advertisers",
                        "type": "array",
                        "description": "Advertiser names to search, e.g. [\"Zalando\", \"About You\"]. Each entry becomes its own search. TikTok matches names loosely, so a search for \"Zalando\" can also return other advertisers whose ads mention it — every result carries `advertiserName` so you can filter exactly.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text search across ad content and advertiser names. Runs as its own search in addition to any advertisers above."
                    },
                    "countries": {
                        "title": "Target countries (ISO codes)",
                        "type": "array",
                        "description": "Two-letter ISO 3166-1 codes of EU/EEA countries to scope the search, e.g. [\"DE\", \"FR\"]. Each country runs as a separate search. Leave empty to search all covered countries at once (recommended).",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only return ads shown on or after this date (YYYY-MM-DD). Defaults to one year ago. TikTok retains Commercial Content Library ads for one year."
                    },
                    "endDate": {
                        "title": "End date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only return ads shown on or before this date (YYYY-MM-DD). Defaults to today."
                    },
                    "includeTargeting": {
                        "title": "Include targeting & advertiser details",
                        "type": "boolean",
                        "description": "Fetch each ad's detail page for the call to action, advertising objective, advertiser business ID and registry country, audience-size estimate, and full targeting breakdown (countries, age bands, gender, languages, impressions by country). Turning this off is faster but returns card-level fields only. Billed the same either way.",
                        "default": true
                    },
                    "maxResultsPerQuery": {
                        "title": "Max ads per search",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on stored ads per advertiser or keyword search (per country). Each stored ad emits exactly one billing event. Raise the run timeout in Run options for large caps — TikTok rate-limits heavy scraping, so big runs take longer than the 5-minute default.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
