# SEC Investor Alerts Scraper (`automation-lab/sec-investor-alerts-scraper`) Actor

Scrape SEC Investor.gov alerts and bulletins with dates, summaries, categories, full text, and source URLs for compliance monitoring.

- **URL**: https://apify.com/automation-lab/sec-investor-alerts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** News
- **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

## SEC Investor Alerts Scraper

Scrape SEC Investor.gov investor alerts and bulletins into a clean dataset for compliance monitoring, fraud-risk research, investor education feeds, and internal knowledge bases.

The actor crawls the public Investor.gov Alerts & Bulletins pages, follows pagination, optionally opens each detail page, and returns structured records with dates, summaries, categories, full body text, source URLs, and scrape metadata.

### What does SEC Investor Alerts Scraper do?

SEC Investor Alerts Scraper turns Investor.gov alerts and bulletins into exportable data.

It can collect:

- 🛡️ SEC investor alerts
- 📌 SEC investor bulletins
- 📅 publication dates
- 🔗 canonical source URLs
- 📝 summaries from the listing page
- 📄 full article body text from detail pages
- 🏷️ categories and tags when available
- ⏱️ scrape timestamps for monitoring workflows

### Who is it for?

This scraper is designed for teams that need a repeatable SEC investor-protection feed.

- Compliance teams monitoring new fraud and investor-protection notices
- Fraud-risk analysts tracking scam themes and enforcement warnings
- Investor-relations teams watching official SEC investor education updates
- Fintech content teams feeding alerts into newsletters or apps
- Legal researchers building archives of investor guidance
- Knowledge-base teams indexing public SEC investor education content

### Why use this actor?

Investor.gov is public, but the Alerts & Bulletins pages are formatted for reading, not for automated workflows.

This actor gives you:

- A structured dataset instead of manual copy and paste
- Detail-page body text for search and RAG workflows
- Consistent dates and source URLs for audit trails
- A low-cost HTTP crawler without browser overhead
- Inputs that work for scheduled monitoring or one-off exports

### Data extracted

| Field | Description |
| --- | --- |
| `title` | Alert or bulletin headline |
| `type` | `Investor Alert`, `Investor Bulletin`, or `Other` |
| `publishedDate` | Normalized ISO date when parseable |
| `publishedDateText` | Raw date text shown by Investor.gov |
| `sourceUrl` | Absolute source URL |
| `summary` | Listing summary or short detail fallback |
| `bodyText` | Full article text when detail extraction is enabled |
| `category` | Source category when present |
| `tags` | Category and breadcrumb-style labels |
| `scrapedAt` | Timestamp when the record was saved |

### How much does it cost to scrape SEC investor alerts?

This actor uses pay-per-event pricing.

- A small start fee is charged once per run.
- A per-item event is charged for each alert or bulletin saved.
- Higher Apify usage tiers receive lower per-item prices.

You can control spend with `maxItems`. For a quick test, use 10-25 items. For a monitoring export, use 100+ items or let the actor crawl the available pages.

### How to use SEC Investor Alerts Scraper

1. Open the actor on Apify.
2. Keep the default Investor.gov Alerts & Bulletins URL or add specific detail URLs.
3. Set `maxItems` to the number of records you need.
4. Keep `includeBody` enabled if you need full article text.
5. Run the actor.
6. Export results as JSON, CSV, Excel, XML, RSS, or through the Apify API.

### Input options

#### Start URLs

Use the main listing URL for normal monitoring:

```text
https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins
````

You can also provide detail URLs when you only need specific alerts or bulletins.

#### Maximum alerts/bulletins

`maxItems` limits the number of dataset rows. This is the main cost-control input.

#### Alert types

Use `types` to limit output to Investor Alerts, Investor Bulletins, or Other pages.

#### Include full body text

When `includeBody` is true, the actor opens detail pages and extracts article text. Disable it for a faster metadata-only run.

#### Request delay

Investor.gov pages are static and public, so no delay is usually needed. Add a delay if you are running very large scheduled jobs.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins" }
  ],
  "maxItems": 100,
  "includeBody": true,
  "maxBodyChars": 20000,
  "requestDelayMs": 0
}
```

### Example output

```json
{
  "title": "Updated Investor Alert: Identity Theft, Data Breaches and Your Investment Accounts",
  "type": "Investor Alert",
  "publishedDate": "2026-04-23",
  "publishedDateText": "April 23, 2026",
  "sourceUrl": "https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins/investor-alerts/investor-59",
  "summary": "In accordance with the President’s Executive Order...",
  "bodyText": "In accordance with the President’s Executive Order...",
  "category": "Enforcement",
  "tags": ["Enforcement"],
  "scrapedAt": "2026-06-30T00:00:00.000Z"
}
```

### Tips for better results

- Use the default listing URL to collect the newest alerts and bulletins.
- Use detail URLs for a small curated list.
- Keep `includeBody` enabled for compliance archives and search indexes.
- Lower `maxItems` for smoke tests.
- Schedule the actor daily or weekly to monitor changes.

### Integrations

Use the output with:

- Google Sheets for compliance review queues
- Slack or email alerts for new Investor.gov warnings
- Notion, Airtable, or databases for internal research libraries
- Vector databases for fraud-risk retrieval workflows
- BI dashboards that track investor-protection themes over time
- RSS or webhook automations for internal monitoring feeds

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-investor-alerts-scraper').call({
  startUrls: [{ url: 'https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins' }],
  maxItems: 100,
  includeBody: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/sec-investor-alerts-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins'}],
    'maxItems': 100,
    'includeBody': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

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

### MCP usage

Connect the actor to Claude Desktop, Claude Code, or other MCP clients through Apify MCP Server:

```text
https://mcp.apify.com/?tools=automation-lab/sec-investor-alerts-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-sec-investor-alerts "https://mcp.apify.com/?tools=automation-lab/sec-investor-alerts-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-sec-investor-alerts": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sec-investor-alerts-scraper"
    }
  }
}
```

Example prompts:

- "Run the SEC investor alerts scraper and summarize new scam warnings."
- "Find the latest Investor.gov bulletins about identity theft."
- "Export SEC investor alerts into a compliance monitoring table."

### Scheduling and monitoring

The actor is useful as a scheduled monitor.

Recommended schedules:

- Daily for fraud-risk monitoring teams
- Weekly for compliance knowledge bases
- Monthly for investor education archives

Store previous results and compare `sourceUrl` values to detect newly published alerts.

### Legality

This actor collects public Investor.gov pages. Respect Apify platform rules, Investor.gov terms, and applicable laws. Do not use the data for deceptive activity. Keep source attribution when redistributing public guidance.

### FAQ

#### Can I scrape only SEC Investor Alerts?

Yes. Set `types` to `["Investor Alert"]` to filter the dataset to alert records only.

#### Can I use the scraper for recurring monitoring?

Yes. Schedule the actor and compare `sourceUrl` values between runs to detect newly published alerts or bulletins.

### Troubleshooting

#### Why did I receive fewer records than expected?

Check `maxItems`, `types`, and whether your start URL is a listing page or a detail page. The source may also have a finite number of current listing pages.

#### Why is `bodyText` empty?

Make sure `includeBody` is true. Some unusual pages may not use the standard Investor.gov article body template; the actor will still save listing metadata when possible.

#### How do I reduce cost?

Lower `maxItems` or disable `includeBody` for metadata-only runs.

### Related scrapers

Explore related public-data actors by Automation Lab:

- https://apify.com/automation-lab/sec-form-adv-scraper
- https://apify.com/automation-lab/sec-investment-adviser-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

#### 0.1

- Initial release with listing pagination, detail extraction, type inference, categories, tags, and full body text.

### Support

If the source page changes or you need additional Investor.gov fields, open an Apify issue with the run URL and desired output fields.

# Actor input Schema

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

Investor.gov Alerts & Bulletins listing pages or individual alert/bulletin detail URLs.

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

Maximum number of records to save. Use 100+ for full-page monitoring and lower values for quick tests.

## `types` (type: `array`):

Optional filter for specific Investor.gov content types. Leave empty to include all records found.

## `includeBody` (type: `boolean`):

Open each alert/bulletin detail page and extract the article body. Disable to collect only list metadata faster.

## `maxBodyChars` (type: `integer`):

Maximum number of body-text characters stored per record. The prefill is intentionally small for cheap first runs; increase for full-text exports.

## `requestDelayMs` (type: `integer`):

Optional polite delay between HTTP requests. The source is public and static, so 0 is usually safe.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins"
    }
  ],
  "maxItems": 20,
  "includeBody": true,
  "maxBodyChars": 20,
  "requestDelayMs": 0
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins"
        }
    ],
    "maxItems": 20,
    "includeBody": true,
    "maxBodyChars": 20,
    "requestDelayMs": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-investor-alerts-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 = {
    "startUrls": [{ "url": "https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins" }],
    "maxItems": 20,
    "includeBody": True,
    "maxBodyChars": 20,
    "requestDelayMs": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-investor-alerts-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 '{
  "startUrls": [
    {
      "url": "https://www.investor.gov/introduction-investing/general-resources/news-alerts/alerts-bulletins"
    }
  ],
  "maxItems": 20,
  "includeBody": true,
  "maxBodyChars": 20,
  "requestDelayMs": 0
}' |
apify call automation-lab/sec-investor-alerts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Investor Alerts Scraper",
        "description": "Scrape SEC Investor.gov alerts and bulletins with dates, summaries, categories, full text, and source URLs for compliance monitoring.",
        "version": "0.1",
        "x-build-id": "eZgx4CmDqsAd575gi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-investor-alerts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-investor-alerts-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~sec-investor-alerts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-investor-alerts-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~sec-investor-alerts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-investor-alerts-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Investor.gov Alerts & Bulletins listing pages or individual alert/bulletin detail URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum alerts/bulletins",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of records to save. Use 100+ for full-page monitoring and lower values for quick tests.",
                        "default": 20
                    },
                    "types": {
                        "title": "Alert types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional filter for specific Investor.gov content types. Leave empty to include all records found.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Investor Alert",
                                "Investor Bulletin",
                                "Other"
                            ],
                            "enumTitles": [
                                "Investor Alert",
                                "Investor Bulletin",
                                "Other"
                            ]
                        }
                    },
                    "includeBody": {
                        "title": "Include full body text",
                        "type": "boolean",
                        "description": "Open each alert/bulletin detail page and extract the article body. Disable to collect only list metadata faster.",
                        "default": true
                    },
                    "maxBodyChars": {
                        "title": "Maximum body characters",
                        "minimum": 20,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of body-text characters stored per record. The prefill is intentionally small for cheap first runs; increase for full-text exports.",
                        "default": 20
                    },
                    "requestDelayMs": {
                        "title": "Request delay (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional polite delay between HTTP requests. The source is public and static, so 0 is usually safe.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```