# BetaList Scraper (`solidcode/betalist-scraper`) Actor

\[💰 $4 / 1K] Extract upcoming startups and new products from BetaList. Scrape by category, browse/topic URL, or keyword: get product name, tagline, description, topics, website, featured date, and logo. Clean JSON/CSV/Excel for lead generation and startup market research.

- **URL**: https://apify.com/solidcode/betalist-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Developer tools, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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

## BetaList Scraper

Pull upcoming startups and freshly launched products from BetaList at scale — names, taglines, full descriptions, topic tags, featured dates, product logos, each founder's profile, and each startup's real external website. Built for growth marketers, VC deal scouts, and market researchers who need a live feed of every new startup launch without checking BetaList by hand.

### Why This Scraper?

- **22 curated markets in one actor** — sweep AI, Dev Tools, HR & Recruiting, Finance, Health, Marketing, Energy & Environment, Data & Analytics, and 14 more, each expanded automatically into every topic underneath it.
- **Founder profile on every startup** — the maker's display name, their BetaList handle, and a direct link to their profile page, so you can reach the person behind the launch, not just a company page.
- **Resolves each startup's real external website** — not just the BetaList page, but the founder's actual product URL, followed through BetaList's redirect and cleaned of tracking parameters — the link you need for outreach.
- **ISO-formatted featured dates** — every product's launch date as `YYYY-MM-DD`, ready to sort, filter, and chart for time-series trend analysis.
- **Full tagline, description, and topic tags on every row** — the one-line pitch, the long-form description, and the array of category tags a founder chose, all in a single flat record.
- **Four ways to target startups** — pick from 22 categories, paste any browse, market, topic, or search URL, drop a single `/startups/<slug>` product link, or search by keyword.
- **Collect every startup, or cap it exactly** — set a precise result limit, or set `0` to sweep everything in a category (up to a 50,000-result safety ceiling per run).
- **Product logo image URL on every startup** — the thumbnail shown on the launch card, ready to embed in newsletters, CRMs, or dashboards.
- **One clean flat row per startup** — twelve typed fields, no nested blobs, exporting straight to JSON, CSV, or Excel.

### Use Cases

**Lead Generation**
- Build outreach lists of brand-new startups the week they launch
- Reach founders through their real product website, not a directory page
- Filter by market to target only the verticals you sell into
- Feed fresh company names and taglines straight into your CRM

**Market & Trend Research**
- Track what's launching in AI, Fintech, or Health month over month
- Chart launch volume by featured date to spot emerging waves
- Map which topics dominate a category's new-product pipeline
- Benchmark how many products enter a market over time

**Investor & VC Deal Sourcing**
- Spot early-stage products the day they go public on BetaList
- Sweep a target vertical for every new entrant in one run
- Enrich a deal pipeline with taglines, descriptions, and websites
- Set up a repeatable weekly scan of your thesis categories

**Competitive Intelligence**
- Monitor new entrants into a market you already operate in
- Watch a specific topic feed for direct competitors as they launch
- Compare how rivals position themselves via tagline and description
- Keep a running log of everything shipping in your space

**Content & Media**
- Curate "new launches this week" newsletters automatically
- Source products for roundups, directories, and trend pieces
- Pull logos, taglines, and links ready to drop into a post
- Track a niche topic to never miss a launch worth covering

### Getting Started

#### Search by Keyword

The quickest way to start — one keyword against the discovery feed:

```json
{
    "searchTerm": "scheduling",
    "maxResults": 50
}
````

#### Scrape a Category

Pick one or more of the 22 markets — every topic underneath is expanded and collected:

```json
{
    "category": ["ai", "dev-tools"],
    "maxResults": 200
}
```

#### Scrape Specific URLs

Paste any BetaList browse, market, topic, or search page — or a single product page:

```json
{
    "startUrls": [
        "https://betalist.com/browse/ai/ai-assistant",
        "https://betalist.com/browse/finance",
        "https://betalist.com/startups/plumb-ace"
    ],
    "maxResults": 0
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | array | `["ai"]` | Pick one or more BetaList categories to scrape. The easiest way to start — no URL needed. Each category is expanded into its topics, and every startup in those topics is collected. Ignored when Start URLs are provided. |
| `startUrls` | array | `[]` | Paste BetaList URLs to scrape. These can be topic pages (e.g. `https://betalist.com/browse/ai/ai-assistant`), category pages (e.g. `https://betalist.com/browse/ai`), search pages, the homepage, or specific startup pages (e.g. `https://betalist.com/startups/plumb-ace`). When set, this overrides the Categories option. |
| `searchTerm` | string | `""` | Optional keyword to scrape the BetaList discovery feed by term (e.g. "crypto", "scheduling"). Leave empty to skip keyword search. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of startups to return across all inputs. Set to 0 for unlimited — collect every startup found, up to a 50,000-result safety ceiling per run. The last page is always collected in full, so a run may return slightly more than this number. |

Provide at least one of `category`, `startUrls`, or `searchTerm`. Start URLs take priority over Categories.

### Output

Each record is one startup with twelve structured fields:

```json
{
    "slug": "sendmux",
    "name": "SendMux",
    "tagline": "One API for transactional email across every provider",
    "description": "SendMux routes your transactional email through multiple providers from a single API, failing over automatically so your password resets and receipts always get delivered.",
    "topics": ["Developer APIs", "Email", "Dev Tools"],
    "makerName": "Roshan Jonnalagadda",
    "makerUrl": "https://betalist.com/@roshanjonah",
    "makerIdentifier": "roshanjonah",
    "featuredDate": "2026-06-28",
    "websiteUrl": "https://sendmux.com",
    "betalistUrl": "https://betalist.com/startups/sendmux",
    "imageUrl": "https://betalist.imgix.net/uploads/sendmux-logo.png"
}
```

#### Fields

| Field | Type | Description |
|-------|------|-------------|
| `slug` | string | Unique BetaList identifier for the startup (from its page URL). |
| `name` | string | Startup or product name. |
| `tagline` | string | One-line pitch shown on the launch card. |
| `description` | string | Full long-form product description from the startup's page. |
| `topics` | string\[] | Topic and category tags the startup is filed under. |
| `makerName` | string | Display name of the startup's maker (founder), when listed. |
| `makerUrl` | string | Direct link to the maker's BetaList profile page, when listed. |
| `makerIdentifier` | string | The maker's BetaList handle (the `@username`, without the `@`), when listed. |
| `featuredDate` | string | Date the product was featured on BetaList, as ISO `YYYY-MM-DD`. |
| `websiteUrl` | string | The startup's real external website, resolved through BetaList's redirect. |
| `betalistUrl` | string | The startup's page on BetaList. |
| `imageUrl` | string | Product logo or thumbnail image URL. |

Maker fields populate on startups that list a founder on their BetaList page (most do); they are left empty when a startup has none.

### Tips for Best Results

- **Start small, then scale** — set `maxResults` to 25–50 on your first run to confirm the data fits your workflow, then raise it or set `0` to sweep everything (a single run collects up to 50,000 startups).
- **Category vs. topic — pick your breadth** — a category pick sweeps every topic in that market for maximum coverage; paste a single topic URL (e.g. `.../browse/ai/ai-assistant`) when you want to stay narrow and focused.
- **Chain multiple markets** — pass several categories in one run to build a cross-vertical launch feed in a single pass.
- **Use `searchTerm` for themes that cross categories** — keywords like "crypto" or "no-code" catch products filed under different markets that a single category would miss.
- **Sort by `featuredDate` for a launch timeline** — because dates are ISO-formatted, a simple sort turns your export into a chronological feed of new launches.
- **Reach founders two ways** — `websiteUrl` is the real product site for enrichment and product research, while `makerUrl` and `makerName` give you the founder's own BetaList profile for direct, person-to-person outreach.
- **Re-run on a schedule** — set the same category run to repeat weekly to catch every new launch as it lands.

### Pricing

**From $4 per 1,000 results** — pay only for the startups you actually collect. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.25 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.50 | $40.00 |
| 100,000 | $480.00 | $450.00 | $425.00 | $400.00 |

A "result" is any startup row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, lead generation, and competitive analysis. Users are responsible for complying with applicable laws and BetaList's Terms of Service. Do not use collected data for spam, harassment, or any illegal purpose, and respect the wishes of founders who ask not to be contacted.

# Actor input Schema

## `category` (type: `array`):

Pick one or more BetaList categories to scrape. The easiest way to start — no URL needed. Each category is expanded into its topics, and every startup in those topics is collected. Ignored when Start URLs are provided.

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

Paste BetaList URLs to scrape. These can be topic pages (e.g. https://betalist.com/browse/ai/ai-assistant), category pages (e.g. https://betalist.com/browse/ai), search pages, the homepage, or specific startup pages (e.g. https://betalist.com/startups/plumb-ace). When set, this overrides the Categories option.

## `searchTerm` (type: `string`):

Optional keyword to scrape the BetaList discovery feed by term (e.g. "crypto", "scheduling"). Leave empty to skip keyword search.

## `maxResults` (type: `integer`):

Maximum number of startups to return across all inputs. Set to 0 for unlimited — collect every startup found, up to a 50,000-result safety ceiling per run. The last page is always collected in full, so a run may return slightly more than this number.

## Actor input object example

```json
{
  "category": [
    "ai"
  ],
  "startUrls": [],
  "maxResults": 100
}
```

# Actor output Schema

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

Compact table of scraped startups — name, tagline, topics, and BetaList URL.

## `details` (type: `string`):

Full startup metadata including description, maker/founder profile, website, featured date, and logo.

# 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 = {
    "category": [
        "ai"
    ],
    "startUrls": [],
    "searchTerm": "",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/betalist-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 = {
    "category": ["ai"],
    "startUrls": [],
    "searchTerm": "",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/betalist-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 '{
  "category": [
    "ai"
  ],
  "startUrls": [],
  "searchTerm": "",
  "maxResults": 100
}' |
apify call solidcode/betalist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BetaList Scraper",
        "description": "[💰 $4 / 1K] Extract upcoming startups and new products from BetaList. Scrape by category, browse/topic URL, or keyword: get product name, tagline, description, topics, website, featured date, and logo. Clean JSON/CSV/Excel for lead generation and startup market research.",
        "version": "1.0",
        "x-build-id": "VxpfEzWqDM0ZE2HYX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~betalist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-betalist-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/solidcode~betalist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-betalist-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/solidcode~betalist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-betalist-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": {
                    "category": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Pick one or more BetaList categories to scrape. The easiest way to start — no URL needed. Each category is expanded into its topics, and every startup in those topics is collected. Ignored when Start URLs are provided.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ai",
                                "commerce",
                                "customer-support",
                                "data-analytics",
                                "design-creative",
                                "dev-tools",
                                "education",
                                "energy-environment",
                                "finance",
                                "government-defense",
                                "hardware",
                                "health",
                                "hr-recruiting",
                                "industrial",
                                "legal",
                                "marketing",
                                "media-content",
                                "productivity",
                                "sales",
                                "security-privacy",
                                "social-community",
                                "travel-hospitality"
                            ],
                            "enumTitles": [
                                "AI",
                                "Commerce",
                                "Customer Support",
                                "Data & Analytics",
                                "Design & Creative",
                                "Dev Tools",
                                "Education",
                                "Energy & Environment",
                                "Finance",
                                "Government & Defense",
                                "Hardware",
                                "Health",
                                "HR & Recruiting",
                                "Industrial",
                                "Legal",
                                "Marketing",
                                "Media & Content",
                                "Productivity",
                                "Sales",
                                "Security & Privacy",
                                "Social & Community",
                                "Travel & Hospitality"
                            ]
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste BetaList URLs to scrape. These can be topic pages (e.g. https://betalist.com/browse/ai/ai-assistant), category pages (e.g. https://betalist.com/browse/ai), search pages, the homepage, or specific startup pages (e.g. https://betalist.com/startups/plumb-ace). When set, this overrides the Categories option.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerm": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Optional keyword to scrape the BetaList discovery feed by term (e.g. \"crypto\", \"scheduling\"). Leave empty to skip keyword search."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of startups to return across all inputs. Set to 0 for unlimited — collect every startup found, up to a 50,000-result safety ceiling per run. The last page is always collected in full, so a run may return slightly more than this number.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
