# Alien Ads Library Scraper (`automation-lab/alien-ads-library-scraper`) Actor

👽 Export public Reddit ad creatives, advertisers, landing pages, media, and activity dates from Alien Ads Library for competitive intelligence.

- **URL**: https://apify.com/automation-lab/alien-ads-library-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.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

## Alien Ads Library Scraper

Collect public Reddit ad creatives from [Alien Ads Library](https://alienadslibrary.com/) as structured, export-ready data.

Use the actor to research advertisers, archive creative concepts, inspect landing-page destinations, and monitor when Reddit ads first or last appeared. No Alien Ads Library account or Reddit login is required.

### What does Alien Ads Library Scraper do?

Alien Ads Library Scraper reads the public ad catalog and saves one dataset row per Reddit ad.

It extracts:

- ad headline and body copy
- advertiser username
- destination URL and domain
- original and archived media URLs
- Reddit post ID and direct Reddit link
- category and subreddit, when available
- first-seen, last-seen, and Reddit creation dates
- active status and creative performance score, when available
- direct source link back to Alien Ads Library

The actor follows the catalog cursor automatically, so a single run can collect more than the first page.

### Why use this Reddit ads scraper?

Manual ad-library research is useful but difficult to repeat at scale.

This actor turns the catalog into JSON, CSV, Excel, XML, or RSS exports that can feed analysis and monitoring workflows.

Typical benefits include:

- compare competitors without copying cards by hand
- build a searchable creative swipe file
- discover domains buying Reddit traffic
- track changes with scheduled runs
- send new records into Sheets, databases, or BI tools
- summarize creative themes with an LLM

### Who is it for?

#### Paid social teams

Review how brands position products in Reddit-native ad copy.

#### Creative strategists

Collect headlines and media references for concept analysis and briefing.

#### Competitive intelligence teams

Monitor advertiser activity, destinations, and creative longevity.

#### Agencies

Create repeatable research exports for client categories and pitches.

#### Growth and product marketing teams

Study offers, calls to action, and landing-page patterns used by active advertisers.

#### Data teams

Load normalized ad records into a warehouse or internal dashboard.

### What data can you extract?

| Field | Type | Description |
|---|---|---|
| `id` | number | Alien Ads Library record ID |
| `redditId` | string | Reddit thing ID |
| `redditUrl` | string | Direct Reddit comments URL |
| `headline` | string/null | Ad headline or primary creative copy |
| `bodyText` | string/null | Additional body text |
| `adType` | string | Ad type reported by the source |
| `advertiserUsername` | string/null | Reddit advertiser username |
| `advertiserUrl` | string/null | Alien Ads Library advertiser URL |
| `destinationUrl` | string/null | Normalized landing-page URL |
| `destinationDomain` | string/null | Landing-page hostname |
| `mediaUrl` | string/null | Original media URL |
| `archivedMediaUrl` | string/null | Archived creative media URL |
| `subreddit` | string/null | Target or associated subreddit when available |
| `category` | string/null | Catalog category when available |
| `creativePerformanceScore` | number/null | Source performance score when available |
| `redditCreatedAt` | string/null | Reddit creation time in ISO 8601 |
| `firstSeenAt` | string/null | First observed time in ISO 8601 |
| `lastSeenAt` | string/null | Last observed time in ISO 8601 |
| `isActive` | boolean | Whether the source marks the ad active |
| `sourceUrl` | string | Alien Ads Library ad detail URL |
| `scrapedAt` | string | Extraction time in ISO 8601 |

### Input

The actor accepts three simple settings.

```json
{
  "maxItems": 100,
  "featuredOnly": false,
  "category": ""
}
````

#### `maxItems`

Maximum number of ad records to save.

The default is 100, while the Store prefill is 25 for a quick first run.

Allowed range: 1 to 10,000.

#### `category`

Optional exact category label from Alien Ads Library.

Leave it empty to browse ads without a category restriction.

#### `featuredOnly`

Set to `true` to request only records selected as featured by the source.

### How to scrape Reddit ads

1. Open Alien Ads Library Scraper on Apify.
2. Choose the maximum number of ads.
3. Optionally enter an exact category or enable featured-only mode.
4. Click **Start**.
5. Open the **Dataset** tab when the run finishes.
6. Export the data or connect it to another service.

### Example output

```json
{
  "id": 2464,
  "redditId": "t3_1qeyic5",
  "redditUrl": "https://www.reddit.com/comments/1qeyic5",
  "headline": "Get 30% off the easiest way to eat healthy.",
  "adType": "sponsored",
  "advertiserUsername": "Hungryroot",
  "destinationDomain": "eat.hungryroot.com",
  "mediaUrl": "https://external-preview.redd.it/example.png",
  "firstSeenAt": "2026-01-20T15:51:34.000Z",
  "lastSeenAt": "2026-03-24T21:17:05.000Z",
  "isActive": true,
  "sourceUrl": "https://alienadslibrary.com/ads/2464-example",
  "scrapedAt": "2026-07-12T04:24:25.004Z"
}
```

Nullable fields are retained as `null` when the public catalog does not provide a value.

### How much does it cost to scrape Alien Ads Library?

This actor uses pay-per-event pricing.

A small one-time start charge covers run setup, followed by a charge for each dataset item produced.

Your Apify plan receives automatic volume discounts through tiered event pricing.

The exact live price is shown before you start a run. You never pay for a requested record that is not saved.

For cost control, begin with 25 records and increase `maxItems` after checking the output.

### Monitoring new Reddit ad creatives

Create an Apify schedule to run the actor daily or weekly.

Use `redditId` or `id` as a stable key in your destination system.

Compare `firstSeenAt`, `lastSeenAt`, and `isActive` to identify newly observed or persistent creatives.

Apify integrations can send every run to a webhook, Google Sheets, Make, Zapier, or another actor.

### Creative research workflow

A practical creative-analysis workflow is:

1. collect 100–500 ads
2. group records by `destinationDomain` or `advertiserUsername`
3. download or reference `archivedMediaUrl`
4. classify headline themes with an LLM
5. compare first-seen and last-seen dates
6. save durable concepts to a swipe-file database

Long observation windows do not prove spend or performance, but they can help prioritize manual research.

### Advertiser discovery workflow

Export `advertiserUsername`, `destinationDomain`, and `destinationUrl`.

Deduplicate domains in a spreadsheet or database.

Enrich the resulting company list with your authorized business-data provider.

This is useful for agency prospecting, market maps, and competitive landscape research.

### Integrations

#### Google Sheets

Send dataset rows to Sheets for sorting, tagging, and collaborative review.

#### Make and Zapier

Trigger downstream automation after each scheduled run.

#### Webhooks

Receive a run-finished event and fetch the default dataset through the Apify API.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, PostgreSQL, or another warehouse.

#### Other Apify Actors

Chain this actor with authorized website extractors, text classifiers, or notification actors.

### API usage

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/alien-ads-library-scraper').call({
  maxItems: 100,
  featuredOnly: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/alien-ads-library-scraper').call(
    run_input={'maxItems': 100, 'featuredOnly': True}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~alien-ads-library-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":100,"featuredOnly":true}'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use with Apify MCP

Connect the actor to Claude Code or another MCP client through Apify MCP Server.

Use this tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/alien-ads-library-scraper
```

Example prompts:

- “Collect 100 featured Reddit ads and group them by destination domain.”
- “Find repeated offer patterns in these Alien Ads Library records.”
- “Compare advertisers first seen in this run with last week's dataset.”

For Claude Desktop, add Apify MCP Server using the configuration instructions in the Apify Console, then enable this actor as a tool.

### Tips for reliable runs

- Use a low `maxItems` while validating a new workflow.
- Leave `category` empty unless you know the exact current source label.
- Use `featuredOnly` for a narrower curated feed.
- Schedule moderate runs instead of repeatedly collecting the whole catalog.
- Deduplicate on `redditId` when combining runs.
- Treat nullable source fields as expected rather than extraction failures.
- Keep source and Reddit URLs for later verification.

### Limitations

The actor exposes public records available from Alien Ads Library at run time.

It does not provide private Reddit campaign settings, spend, impressions, targeting, conversions, or advertiser contact details.

Catalog coverage and freshness are controlled by Alien Ads Library, not by this actor.

A source record can omit headline, body, category, subreddit, media, score, or destination details.

Category labels can change upstream.

Source API changes or temporary availability issues may affect a run; transient requests are retried automatically.

### Data quality notes

Timestamps are converted from source Unix values to ISO 8601 UTC strings.

HTML-escaped ampersands in destination and media URLs are normalized.

`isActive` reflects the source flag and should not be interpreted as guaranteed real-time Reddit delivery.

`creativePerformanceScore` is included only when the source supplies it; the actor does not calculate that score.

### Legality

This actor collects publicly accessible catalog data without bypassing login controls.

Public availability does not remove your responsibility to follow applicable laws, website terms, intellectual-property rules, and privacy obligations.

Use the data for legitimate research and processing, avoid prohibited republication, and obtain legal advice for regulated or high-risk use cases.

Do not use the actor to harass advertisers, misrepresent affiliation, or unlawfully profile people.

### Troubleshooting

#### My dataset is empty

Check whether the category value exactly matches a current Alien Ads Library category.

Remove the category and retry a small run to distinguish a filter mismatch from source availability.

#### I received fewer records than requested

The selected filter may contain fewer public records, or the source may have reached the end of its current feed.

Review the run log for the saved count.

#### Some fields are null

Alien Ads Library does not populate every field for every ad. Nullable values are part of the source data contract.

#### A media URL no longer works

Try `archivedMediaUrl`, which may be more durable than the original Reddit-hosted URL.

#### A run fails temporarily

Retry after checking the public target is reachable. The actor already retries transient request failures three times.

### FAQ

#### Does this actor require a Reddit account?

No. It reads a public third-party catalog and does not log in to Reddit.

#### Does it download media files?

No. It returns original and archived media URLs, keeping runs fast and exports lightweight.

#### Can it scrape more than one page?

Yes. Cursor pagination continues until `maxItems` is reached or the source has no next page.

#### Can I filter by advertiser?

The current release focuses on the catalog's public category and featured filters. Filter exported rows by `advertiserUsername` or `destinationDomain` downstream.

#### Does `isActive` guarantee the campaign is spending now?

No. It reproduces the source's status flag and is not a direct Reddit Ads delivery signal.

#### Can I run it on a schedule?

Yes. Apify schedules are ideal for repeat monitoring.

#### How should I identify duplicate ads?

Use `redditId` as the primary stable key and retain `id` for source reconciliation.

### Related scrapers

Combine this actor with relevant Automation Lab tools when your workflow requires broader public web research:

- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper) for public Reddit content
- [Google Ads Transparency Scraper](https://apify.com/automation-lab/google-ads-transparency-scraper) for cross-network ad research
- [TikTok Creative Center Scraper](https://apify.com/automation-lab/tiktok-creative-center-scraper) for creative trend comparisons

Only use related actors when their sources and terms fit your use case.

### Support

If a run behaves unexpectedly, open an issue from the actor's Apify page.

Include a small reproducible input, the run ID, expected result, and observed result.

Do not include secrets or personal credentials in support messages.

# Actor input Schema

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

Maximum number of Reddit ad records to save.

## `category` (type: `string`):

Optional exact Alien Ads Library category filter. Leave empty to collect all categories.

## `featuredOnly` (type: `boolean`):

Limit results to ads selected as featured by Alien Ads Library.

## Actor input object example

```json
{
  "maxItems": 20,
  "featuredOnly": 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 = {
    "maxItems": 20
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Alien Ads Library Scraper",
        "description": "👽 Export public Reddit ad creatives, advertisers, landing pages, media, and activity dates from Alien Ads Library for competitive intelligence.",
        "version": "0.1",
        "x-build-id": "pemvpSGPaAE0O5bvy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~alien-ads-library-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-alien-ads-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/automation-lab~alien-ads-library-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-alien-ads-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/automation-lab~alien-ads-library-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-alien-ads-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": {
                    "maxItems": {
                        "title": "📊 Maximum ads",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Reddit ad records to save.",
                        "default": 100
                    },
                    "category": {
                        "title": "🏷️ Category",
                        "type": "string",
                        "description": "Optional exact Alien Ads Library category filter. Leave empty to collect all categories."
                    },
                    "featuredOnly": {
                        "title": "⭐ Featured ads only",
                        "type": "boolean",
                        "description": "Limit results to ads selected as featured by Alien Ads Library.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
