# Microsoft Ads Transparency Scraper (`automation-lab/microsoft-ads-transparency-scraper`) Actor

Extract public Microsoft and Bing ads, advertiser identities, creative copy, landing pages, and media assets by keyword, market, advertiser, or library URL.

- **URL**: https://apify.com/automation-lab/microsoft-ads-transparency-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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/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

## Microsoft Ads Transparency Scraper

Collect public Microsoft and Bing advertising creatives as structured data. Search by keyword, advertiser ID, market, or a Microsoft Ads Transparency URL and export ad copy, advertiser identity, landing pages, media assets, and direct library links.

Use the Actor for repeatable competitor research instead of manually copying cards from the Microsoft advertising library. It runs through Microsoft's anonymous public transparency interface and needs no Microsoft account or API key.

### What does Microsoft Ads Transparency Scraper do?

The Actor turns Microsoft Ads Transparency search results into export-ready dataset rows.

- Searches ad headlines and descriptions by keyword
- Collects ads belonging to a known advertiser ID
- Accepts public `/ad/{id}` and `/advertiser/{id}` library URLs
- Applies optional two-letter market filters
- Retrieves image assets exposed by Microsoft
- Normalizes landing-page domains
- Deduplicates ads by Microsoft ad ID
- Records the source query on every row
- Supports optional per-ad detail retrieval
- Paginates up to your chosen maximum

### Who is it for?

#### PPC and paid-search agencies

Audit competitor messages, offers, and destination pages before campaign planning.

#### Competitive-intelligence teams

Track how brands position products across Microsoft Search and related inventory.

#### B2B marketing teams

Discover recurring calls to action, product language, and campaign landing domains.

#### Brand-safety researchers

Review advertiser identity alongside public creative and destination information.

#### Journalists and researchers

Build timestamped datasets from a public transparency source for further analysis.

### Why use this Microsoft ads scraper?

Manual library research does not scale across many keywords or repeated checks.

- Schedule searches daily or weekly
- Export results to JSON, CSV, Excel, or XML
- Connect results to databases and automation tools
- Preserve stable IDs for change detection
- Keep query provenance for multi-brand projects
- Limit runs precisely with `maxItems`
- Avoid account and credential management

### What data can I extract?

| Field | Description |
|---|---|
| `adId` | Stable Microsoft ad identifier |
| `advertiserId` | Microsoft advertiser identifier |
| `advertiserName` | Public advertiser name |
| `title` | Ad headline |
| `description` | Public ad copy |
| `displayUrl` | URL shown in the creative |
| `destinationUrl` | Resolved campaign destination supplied by Microsoft |
| `destinationDomain` | Normalized landing-page hostname |
| `creativeType` | Text, Image, or another disclosed asset type |
| `mediaUrls` | Public creative asset URLs |
| `assets` | Asset dimensions, type, and URL |
| `libraryUrl` | Human-readable Microsoft library detail link |
| `detailUrl` | Anonymous public JSON detail endpoint |
| `country` | Requested market filter |
| `query` | Keyword, advertiser, or URL that produced the row |
| `scrapedAt` | ISO timestamp of collection |

Microsoft does not disclose every transparency metric for every ad. Fields such as spend, impressions, payer, beneficiary, and shown dates remain `null` when the public response does not provide them. The Actor never invents estimates.

### How to scrape Microsoft ads step by step

1. Open the Actor input page.
2. Add one or more advertiser or product keywords.
3. Optionally add advertiser IDs or public library URLs.
4. Add country codes if you need specific markets.
5. Choose the maximum number of unique ads.
6. Enable detail retrieval when creative media is important.
7. Start the run.
8. Preview the Microsoft ads dataset.
9. Export it or connect an integration.

### Input

A simple keyword search:

```json
{
  "searchTerms": ["Copilot"],
  "countries": ["US"],
  "maxItems": 100
}
````

An advertiser monitor:

```json
{
  "advertiserIds": [4295212599],
  "maxItems": 500,
  "fetchDetails": true
}
```

A direct ad lookup:

```json
{
  "startUrls": [
    { "url": "https://adlibrary.ads.microsoft.com/ad/84250661497235" }
  ],
  "maxItems": 1,
  "fetchDetails": true
}
```

### Input reference

#### `searchTerms`

An array of advertiser names, brands, products, or phrases. When omitted with all other sources, the low-cost default searches for `Microsoft`.

#### `advertiserIds`

Numeric or string IDs from Microsoft Ads Transparency advertiser pages.

#### `startUrls`

Public ad or advertiser URLs copied from `adlibrary.ads.microsoft.com`.

#### `countries`

Optional ISO two-letter country codes such as `US`, `GB`, `DE`, or `FR`.

#### `startDate` and `endDate`

Optional dates in `YYYY-MM-DD` format. Availability and interpretation depend on Microsoft's current public API behavior.

#### `maxItems`

Maximum unique ads saved across all input sources. The range is 1 to 10,000.

#### `fetchDetails`

When enabled, requests each ad's public detail endpoint. This improves asset completeness but makes one extra request per ad.

### Output example

```json
{
  "adId": "84250661497235",
  "advertiserId": "4295212599",
  "advertiserName": "Microsoft",
  "title": "Copilot+ PCs",
  "description": "From to-do to done",
  "displayUrl": "www.microsoft.com",
  "destinationUrl": "https://www.microsoft.com/windows/copilot-plus-pcs",
  "destinationDomain": "microsoft.com",
  "creativeType": "Image",
  "mediaUrls": ["https://www.bing.com/th?id=..."],
  "country": "US",
  "query": "Copilot",
  "libraryUrl": "https://adlibrary.ads.microsoft.com/ad/84250661497235",
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}
```

### How much does it cost to scrape Microsoft ads?

This Actor uses pay-per-event pricing: a small start charge plus a charge for each dataset item. Apify plan tiers receive the tiered item prices shown on the Actor page. You control the final run size with `maxItems` and can preview the low default before scaling.

HTTP-only extraction keeps compute use low. Enabling `fetchDetails` adds requests but does not create duplicate records.

### Tips for better results

- Use specific product or brand phrases rather than generic words.
- Search a verified advertiser ID when name matching is too broad.
- Split unrelated markets into separate scheduled tasks.
- Keep `fetchDetails` off for fast text-only discovery.
- Turn `fetchDetails` on when image URLs are required.
- Deduplicate historical exports with `adId`.
- Group results by `destinationDomain` to compare campaign funnels.
- Keep `query` when combining several searches.

### Scheduling a competitor monitor

Create an Apify Task with stable advertiser IDs or keywords. Schedule it daily or weekly. Send each completed dataset to a webhook, cloud table, or your own database. Compare `adId`, title, description, destination URL, and media URLs against the previous snapshot to identify launches and creative changes.

### Integrations

#### Google Sheets

Send new rows to a shared creative-research sheet after each scheduled run.

#### Make

Trigger a scenario when a dataset contains a previously unseen ad ID.

#### Zapier

Route ads matching a priority landing domain to Slack or email.

#### Webhooks

Notify your data pipeline after a run succeeds and fetch the dataset through the API.

#### Cloud storage

Export JSON or CSV snapshots for long-term campaign history.

### API usage

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/microsoft-ads-transparency-scraper').call({
  searchTerms: ['Copilot'], countries: ['US'], maxItems: 100
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/microsoft-ads-transparency-scraper').call(
    run_input={'searchTerms': ['Copilot'], 'countries': ['US'], 'maxItems': 100}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~microsoft-ads-transparency-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["Copilot"],"countries":["US"],"maxItems":100}'
```

### Use with MCP and AI agents

Connect Apify MCP at `https://mcp.apify.com?tools=automation-lab/microsoft-ads-transparency-scraper`.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/microsoft-ads-transparency-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this HTTP server to the client's MCP JSON configuration (set `APIFY_TOKEN` in the client environment):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/microsoft-ads-transparency-scraper"
    }
  }
}
```

Example prompts:

- “Find 100 public Microsoft ads mentioning Copilot in the US.”
- “Extract current creatives for Microsoft advertiser ID 4295212599.”
- “Compare landing domains in this week's Microsoft advertising dataset.”

### Reliability and responsible limits

The Actor retries temporary throttling and server errors with bounded backoff. It deduplicates records before charging and saving them. Concurrency is intentionally conservative because the official public endpoint is optimized for transparency lookup rather than bulk advertising delivery.

A run fails clearly when Microsoft returns a persistent error. Existing items remain available in the dataset.

### Data quality notes

- Asset availability varies by ad format.
- Destination URLs may include campaign tracking parameters.
- Country records the requested market, not inferred targeting.
- Public responses can change as Microsoft updates the library.
- Nullable disclosure fields mean “not provided,” not zero.
- Ad text remains in the language supplied by Microsoft.

### Legality

The Actor accesses public, anonymous transparency data. Laws and contractual requirements differ by jurisdiction and use case. Collect only data you have a lawful reason to process, respect intellectual-property rights, avoid harmful profiling, and follow Microsoft and Apify terms. This is not legal advice.

### FAQ

#### Does it require a Microsoft Ads account?

No. It uses the public anonymous Ads Transparency interface.

#### Can I search by advertiser name?

Yes. Put the advertiser name in `searchTerms`. For precise recurring monitoring, use the advertiser ID.

#### Why are impression or spend fields null?

Microsoft's public response does not provide those fields for every record. The Actor preserves them as nullable rather than estimating values.

#### Why does an ad have no image?

Some records are text ads, and some public records do not expose assets. Enable `fetchDetails` to request the latest public detail representation.

#### How do I avoid duplicate ads?

The Actor deduplicates within each run by `adId`. Use the same key when merging datasets across runs.

#### My search returns too many unrelated results. What should I do?

Use a more specific phrase, add a country, or find the advertiser ID and search it directly.

#### Can I monitor several competitors?

Yes. Add several keywords or advertiser IDs and schedule the task. Every item retains its source query.

#### Can I scrape one known ad?

Yes. Add its public `/ad/{id}` URL to `startUrls`.

### Related ad library scrapers

Build a broader paid-media view with other actors from automation-lab:

- [Google Ads Transparency Scraper](https://apify.com/automation-lab/google-ads-transparency-scraper)
- [LinkedIn Ads Scraper](https://apify.com/automation-lab/linkedin-ads-scraper)
- [Meta Ads Scraper](https://apify.com/automation-lab/meta-ads-scraper)
- [Pinterest Ads Scraper](https://apify.com/automation-lab/pinterest-ads-scraper)
- [Snapchat Ads Scraper](https://apify.com/automation-lab/snapchat-ads-scraper)

### Support

If a valid public Microsoft Ads Transparency URL or search unexpectedly fails, open an issue from the Actor page. Include a redacted input, run ID, expected behavior, and whether the same query works in the public library. Do not post private credentials or proprietary campaign data.

# Actor input Schema

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

Keywords to search in public Microsoft ads.

## `advertiserIds` (type: `array`):

Microsoft Ads Transparency advertiser IDs.

## `startUrls` (type: `array`):

Public /ad/{id} or /advertiser/{id} URLs.

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

Optional ISO two-letter market codes, for example US or GB.

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

Optional first date in YYYY-MM-DD format.

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

Optional last date in YYYY-MM-DD format.

## `maxItems` (type: `integer`):

Stop after this many unique ads.

## `fetchDetails` (type: `boolean`):

Make an additional request per ad for the latest creative assets.

## Actor input object example

```json
{
  "searchTerms": [
    "Microsoft"
  ],
  "maxItems": 20,
  "fetchDetails": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchTerms": [
        "Microsoft"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/microsoft-ads-transparency-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 = {
    "searchTerms": ["Microsoft"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/microsoft-ads-transparency-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 '{
  "searchTerms": [
    "Microsoft"
  ],
  "maxItems": 20
}' |
apify call automation-lab/microsoft-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Microsoft Ads Transparency Scraper",
        "description": "Extract public Microsoft and Bing ads, advertiser identities, creative copy, landing pages, and media assets by keyword, market, advertiser, or library URL.",
        "version": "0.1",
        "x-build-id": "LRFz1sC6AUE5MaWeE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~microsoft-ads-transparency-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-microsoft-ads-transparency-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/automation-lab~microsoft-ads-transparency-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-microsoft-ads-transparency-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/automation-lab~microsoft-ads-transparency-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-microsoft-ads-transparency-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "🔎 Advertiser or ad keywords",
                        "type": "array",
                        "description": "Keywords to search in public Microsoft ads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "advertiserIds": {
                        "title": "Advertiser IDs",
                        "type": "array",
                        "description": "Microsoft Ads Transparency advertiser IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Microsoft Ads Transparency URLs",
                        "type": "array",
                        "description": "Public /ad/{id} or /advertiser/{id} URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "countries": {
                        "title": "🌍 Country codes",
                        "type": "array",
                        "description": "Optional ISO two-letter market codes, for example US or GB.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Optional first date in YYYY-MM-DD format."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Optional last date in YYYY-MM-DD format."
                    },
                    "maxItems": {
                        "title": "Maximum ads",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique ads.",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "Fetch each ad detail",
                        "type": "boolean",
                        "description": "Make an additional request per ad for the latest creative assets.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
