# Substack Notes Search and Author Monitor (`automation-lab/substack-notes-search-author-monitor`) Actor

🔎 Search public Substack Notes and monitor author activity with stable IDs, text, timestamps, engagement counts, media, and outbound links.

- **URL**: https://apify.com/automation-lab/substack-notes-search-author-monitor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **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

## Substack Notes Search and Author Monitor

Search public Substack Notes, monitor authors, and export clean social-listening data without maintaining a crawler.

The Actor turns keyword searches and public author profiles into structured records containing Note text, stable IDs, author and publication details, timestamps, visible engagement, media, and outbound links.

Use it for repeatable brand monitoring, creator research, sponsorship discovery, and trend analysis.

### What does this Substack Notes scraper do?

- 🔎 Searches public Notes by keyword or phrase.
- 👤 Collects public Notes from author profile URLs.
- 📊 Captures visible likes, replies, and restacks.
- 🔗 Extracts media and outbound links.
- 🕒 Supports date windows for incremental monitoring.
- ♻️ Skips IDs you already processed.
- 🧹 Deduplicates Notes across every input source.

It intentionally focuses on Notes, not newsletter posts or private feeds.

### Who is it for?

#### PR and social-listening teams

Track mentions of brands, executives, products, competitors, and campaigns across Substack's public social layer.

#### Creator agencies and newsletter sponsors

Discover active voices, review recent commentary, and compare visible engagement before outreach.

#### Researchers and analysts

Create reproducible datasets of public discourse with stable IDs, timestamps, and source attribution.

#### Automation builders

Refresh monitors on a schedule and send new records to databases, Slack, Sheets, or data warehouses.

### Why use this Actor?

Substack Notes are useful but difficult to monitor manually at scale.

Search pages change, feeds paginate, and repeated searches create duplicates.

This Actor handles normalization, pagination, filtering, and deduplication so workflows receive consistent JSON records.

### Input

Provide one or both source types:

- `queries`: keyword phrases such as `artificial intelligence`.
- `startUrls`: public Notes search URLs or profiles such as `https://substack.com/@ruben`.

Optional monitoring controls:

- `maxItems`: maximum unique Notes to save.
- `publishedAfter`: inclusive ISO date/time lower bound.
- `publishedBefore`: inclusive ISO date/time upper bound.
- `existingIds`: stable Note IDs to skip.

### Example keyword search input

```json
{
  "queries": ["artificial intelligence", "AI agents"],
  "maxItems": 100,
  "publishedAfter": "2026-01-01T00:00:00Z"
}
````

### Example author monitor input

```json
{
  "startUrls": [{ "url": "https://substack.com/@ruben" }],
  "maxItems": 50,
  "existingIds": ["123456789"]
}
```

### Output data

| Field | Meaning |
|---|---|
| `id` | Stable Substack Note ID |
| `url` | Canonical public Note URL |
| `text` | Full visible Note text |
| `authorId` | Stable author profile ID |
| `authorName` | Display name |
| `authorHandle` | Public profile handle |
| `authorProfileUrl` | Public profile URL |
| `publicationId` | Associated publication ID, when available |
| `publicationName` | Associated publication name |
| `publicationSubdomain` | Publication subdomain |
| `publishedAt` | Note publication timestamp |
| `editedAt` | Edit timestamp, when available |
| `likesCount` | Visible reactions/likes |
| `repliesCount` | Visible reply count |
| `restacksCount` | Visible restack count |
| `mediaUrls` | Attached media URLs |
| `outboundUrls` | Links found in Note content |
| `inputQuery` | Query that produced the record |
| `sourceUrl` | Search or profile source |
| `scrapedAt` | Extraction timestamp |

Unavailable engagement values remain `null`; the Actor does not invent zeros.

### Example output

```json
{
  "id": "292375831",
  "url": "https://substack.com/@ruben/note/c-292375831",
  "text": "You're using Claude for only one thing...",
  "authorId": "339636559",
  "authorName": "Ruben Hassid",
  "authorHandle": "ruben",
  "publishedAt": "2026-07-11T16:00:00.905Z",
  "likesCount": 40,
  "repliesCount": 5,
  "restacksCount": 8,
  "mediaUrls": [],
  "outboundUrls": [],
  "inputQuery": null,
  "sourceUrl": "https://substack.com/@ruben",
  "scrapedAt": "2026-07-12T02:10:33.651Z"
}
```

### How to scrape Substack Notes

1. Open the Actor input page.
2. Add keywords, search URLs, or author profile URLs.
3. Choose a small `maxItems` for your first run.
4. Optionally set date bounds or known IDs.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Incremental monitoring

Store the IDs from each completed run.

On the next run, send them through `existingIds` and set `publishedAfter` to the previous checkpoint.

This produces a clean stream of unseen Notes without post-processing duplicates.

Schedule the Actor hourly, daily, or weekly based on your monitoring needs.

### Search tips

- Use exact brand names for focused monitoring.
- Add common misspellings as separate queries.
- Search product names and executive names independently.
- Use date bounds to keep recurring runs fast.
- Keep IDs in a database for long-running monitors.
- Start broad, inspect results, then narrow noisy phrases.

### Deduplication

Records are deduplicated by stable Note ID across all inputs in a run.

IDs supplied through `existingIds` are also skipped.

The same Note found from two keywords is saved only once.

### How much does it cost to monitor Substack Notes?

This Actor uses pay-per-event pricing.

A small start event covers run initialization, and an item event is charged for each Note saved.

Tier discounts reduce the per-Note price for larger Apify plans.

The Console shows the exact charge before and after each run.

### Apify integrations

Connect completed datasets to:

- Google Sheets for shared mention trackers.
- Slack for new high-engagement Note alerts.
- Zapier or Make for no-code routing.
- Webhooks for immediate downstream processing.
- BigQuery, Snowflake, or PostgreSQL for analysis.
- Amazon S3 for archival datasets.

A useful pattern filters records by `likesCount` before notifying an outreach team.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/substack-notes-search-author-monitor').call({
  queries: ['AI agents'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/substack-notes-search-author-monitor').call(
    run_input={'queries': ['AI agents'], 'maxItems': 100}
)
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~substack-notes-search-author-monitor/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["AI agents"],"maxItems":100}'
```

### Use with Apify MCP

Connect Claude and other MCP clients through this actor-scoped endpoint:

`https://mcp.apify.com?tools=automation-lab/substack-notes-search-author-monitor`

For Claude Code, register the remote HTTP server directly:

```bash
claude mcp add --transport http apify-substack-notes \
  "https://mcp.apify.com?tools=automation-lab/substack-notes-search-author-monitor"
```

For Claude Desktop, Cursor, or VS Code, add this server to the client's MCP JSON configuration (for example, `mcp.json`):

```json
{
  "mcpServers": {
    "apify-substack-notes": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/substack-notes-search-author-monitor"
    }
  }
}
```

Authenticate when the client opens the server, then try actor-specific prompts such as:

- “Find recent Substack Notes mentioning our product.”
- “Monitor this author and summarize Notes with more than 20 likes.”
- “Export outbound links shared by these Substack creators.”

### Data quality

The Actor returns public values exposed by Substack at run time.

Engagement can change after extraction.

Some Notes have no publication association, media, outbound links, or edit timestamp.

Fields are typed consistently and optional values are represented explicitly.

### Reliability

Requests use browser-like headers and bounded retries.

Pagination stops at your item limit or the end of available public results.

Malformed or unsupported URLs fail with actionable messages rather than silent empty output.

### Performance

The Actor uses lightweight HTTP requests rather than launching a browser.

A 256 MB container is sufficient for normal runs.

Large monitors should use focused queries and incremental date bounds.

### Legality and responsible use

Only public Substack data is collected.

You are responsible for your use of the data and compliance with applicable law, privacy requirements, contracts, and platform terms.

Avoid collecting unnecessary personal information.

Do not use the Actor for harassment, spam, or invasive profiling.

### Troubleshooting

#### Why did my query return fewer Notes than expected?

Substack controls public search relevance and availability. Try a broader phrase, remove a narrow date bound, or add related queries.

#### Why does a profile URL fail?

Use a public `https://substack.com/@handle` URL. Private, removed, malformed, or non-Substack URLs are unsupported.

#### Why are engagement fields null?

A null means Substack did not expose the visible count for that Note. It is different from a confirmed zero.

#### Why did my recurring run return no items?

Check whether `existingIds` already contains all matching Notes and whether `publishedAfter` is later than the newest available Note.

### FAQ

#### Does it scrape newsletter posts?

No. The product is deliberately scoped to public Notes. Use a dedicated Substack posts scraper for newsletters.

#### Does it require a Substack login?

No. Supported inputs use public search and public profile data.

#### Can I monitor several authors?

Yes. Add multiple profile URLs and set a combined output limit.

#### Can I export CSV or Excel?

Yes. Every Apify dataset can be downloaded in CSV, Excel, JSON, XML, and other formats.

#### Can I schedule runs?

Yes. Use Apify schedules and webhooks to build recurring monitoring workflows.

### Related scrapers

Explore other public-data tools from [automation-lab](https://apify.com/automation-lab):

- Substack post and publication tools for newsletter content.
- Social media scrapers for cross-network mention monitoring.
- Creator discovery actors for sponsorship research.

### Support

Open an issue from the Actor page with a reproducible public URL, input, and run ID.

Do not include credentials or private data.

We use reproducible reports to keep extraction behavior stable as Substack evolves.

# Actor input Schema

## `queries` (type: `array`):

Keywords or phrases to search in public Substack Notes.

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

Public Notes search URLs or author profile URLs such as https://substack.com/@ruben.

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

Stop after this many unique Notes across all sources.

## `publishedAfter` (type: `string`):

Optional ISO date/time lower bound for incremental monitoring.

## `publishedBefore` (type: `string`):

Optional ISO date/time upper bound.

## `existingIds` (type: `array`):

Optional stable Note IDs to skip when refreshing a monitor.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "startUrls": [
    {
      "url": "https://substack.com/@ruben"
    }
  ],
  "maxItems": 20
}
```

# 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 = {
    "queries": [
        "artificial intelligence"
    ],
    "startUrls": [
        {
            "url": "https://substack.com/@ruben"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/substack-notes-search-author-monitor").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 = {
    "queries": ["artificial intelligence"],
    "startUrls": [{ "url": "https://substack.com/@ruben" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/substack-notes-search-author-monitor").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 '{
  "queries": [
    "artificial intelligence"
  ],
  "startUrls": [
    {
      "url": "https://substack.com/@ruben"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/substack-notes-search-author-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/substack-notes-search-author-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Substack Notes Search and Author Monitor",
        "description": "🔎 Search public Substack Notes and monitor author activity with stable IDs, text, timestamps, engagement counts, media, and outbound links.",
        "version": "0.1",
        "x-build-id": "cpyUnlumAUOuhgbgz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~substack-notes-search-author-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-substack-notes-search-author-monitor",
                "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~substack-notes-search-author-monitor/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-substack-notes-search-author-monitor",
                "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~substack-notes-search-author-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-substack-notes-search-author-monitor",
                "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": {
                    "queries": {
                        "title": "🔎 Keywords",
                        "type": "array",
                        "description": "Keywords or phrases to search in public Substack Notes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Substack search or profile URLs",
                        "type": "array",
                        "description": "Public Notes search URLs or author profile URLs such as https://substack.com/@ruben.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum Notes",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many unique Notes across all sources.",
                        "default": 100
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Optional ISO date/time lower bound for incremental monitoring."
                    },
                    "publishedBefore": {
                        "title": "Published before",
                        "type": "string",
                        "description": "Optional ISO date/time upper bound."
                    },
                    "existingIds": {
                        "title": "Existing Note IDs",
                        "type": "array",
                        "description": "Optional stable Note IDs to skip when refreshing a monitor.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```