# Missouri Secretary of State Business Search Scraper (`crawlerbros/missouri-sos-business-search-scraper`) Actor

Search Missouri's free public Business Entity Search (bsd.sos.mo.gov) by business name or registered agent name. Get entity type, status, charter number, formation date, principal address, registered agent, and more.

- **URL**: https://apify.com/crawlerbros/missouri-sos-business-search-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Missouri Secretary of State Business Search Scraper

Search the **Missouri Secretary of State's** free public Business Entity Search (`bsd.sos.mo.gov`). Look up a business by name or by registered agent name, and get entity type, status, charter number, formation date, principal address, registered agent details, domesticity/home state, duration, and more. HTTP-only via the public search form — no login required.

### Data Source & Usage Notes

**Read this before running a large job.**

- **No login, no CAPTCHA.** The source is a classic ASP.NET WebForms search form with no account wall or CAPTCHA challenge.
- **Cloudflare IP-reputation gate — handled with automatic retries.** The source sits behind Cloudflare, which occasionally denies requests from some of Apify's shared datacenter (AUTO) proxy IPs while allowing others (confirmed live: pass rates vary run to run). This is a plain "Access Denied" response, not a JavaScript challenge or CAPTCHA, and it clears immediately on a fresh IP. The actor automatically retries with a new AUTO-proxy session — generously, not just once or twice — until a request succeeds, so a temporarily-flagged IP does not cause a failed run; it only adds a little latency.
- **Session continuity for detail pages.** Confirmed live: Missouri's detail page (`BusinessEntityDetail.aspx`) returns "Access Denied" when fetched cold (no cookies), but succeeds when fetched with the same session/cookies established by the preceding search. The actor always reuses one session across the search and all of that search's detail-page fetches, and only opens a fresh session (new proxy IP + fresh search-page visit) if a detail fetch is blocked.
- **Two search axes.** Missouri's own form exposes Business Name and Registered Agent search (plus "Name Availability" and "Charter No." axes that are reservation/internal-lookup tools rather than public entity search, and are not exposed here).
- **Full pagination, up to `maxItems`.** The results grid pages at 20 rows per page (confirmed live via the grid's own client-state); the actor automatically follows the grid's "Next Page" control until `maxItems` is reached or the source's own reported total is exhausted, so a broad query (e.g. a single-letter starting-with search) isn't silently capped at the first page.
- **Conservative by design.** `maxItems` caps emitted records. The actor only ever uses Apify's free datacenter (AUTO) proxy group — never a paid residential proxy.
- **Give large registered-agent searches a generous run timeout.** Very common registered-agent names (e.g. "CT Corporation", used by tens of thousands of Missouri entities) draw enough scraping traffic that Cloudflare's IP-reputation gate triggers more often on their detail pages, adding retry latency per row. Each detail-page fetch is individually time-bounded (it can never hang the run), but a `maxItems` of 50+ against a high-traffic agent name can take several minutes end-to-end. For runs like this, set a run timeout of 600s or more (Input > Run options) rather than relying on the platform default for short test runs.
- **Not affiliated with the State of Missouri.** This is an independent third-party tool using the source's own public, no-login search form.

#### Why Missouri instead of Indiana?

This actor was originally scoped as an Indiana INBiz (`bsd.sos.in.gov`) business entity search. Live verification (including a real Playwright browser run from Apify's own datacenter infrastructure, not just a local test) showed the search page itself loads fine, but the actual "Search" action is gated behind a live Google reCAPTCHA v2 checkbox: submitting the form without solving it fails silently client-side (no results, no navigation — confirmed via network capture). Per this project's zero-cost policy, paid CAPTCHA-solving services are not an option, so the target was replaced with Missouri's SOS business search — a free, no-login, no-CAPTCHA ASP.NET platform confirmed live on Apify's own infrastructure to return real search results and real entity-detail data (Missouri's own Cloudflare gate is a plain IP-reputation "Access Denied" response, not a JS/CAPTCHA challenge, and is fully solvable with proxy-session retries — no residential proxy or paid service required).

### What this actor does

- **2 search modes**, matching the public axes Missouri's own search form exposes:
  - `byBusinessName` — business/entity name search
  - `byRegisteredAgent` — registered agent name search
- **4 name-match methods** on every search: starting with, all words, any word, exact match — mirroring the source form's own dropdown
- **Active-only filter** — restrict to Good Standing / active entities
- **Full entity detail** — automatically follows through from search results to each entity's detail page for entity type, charter number, domesticity, home state, principal address, registered agent name + address, formation date, and duration
- **Graceful degradation** — if a single entity's detail page cannot be resolved after retries, the record still ships with the fields available from the search-results grid (name, charter number, entity type, status, registration date, registered agent name) rather than being dropped
- **Empty fields are omitted**

### What's NOT included (and why)

- **Only one entity per matching registered agent record.** Missouri's own registered-agent results grid shows one representative entity per matching agent row (with a "(Click to see all N corporations represented)" note when an agent represents more than one) rather than every entity that agent represents. This mirrors the source's own search grid; use a more specific agent-name match (e.g. `exactMatch`) to reduce ambiguity, or use `byBusinessName` if you already know the entity name.
- **Individual-person registered agents** — Missouri's own registered-agent search form defaults to an "Agent is Individual" sub-mode (first/last name) alongside "Agent is Organization" (a single free-text name). This actor always searches the Organization sub-type, since the vast majority of registered agents are organizations (CSC, CT Corporation, law firms, etc.) and `searchTerm` in mode=byRegisteredAgent is documented as a single name field.
- **"Name Availability" and "Charter No." search axes** — Missouri's form exposes these as additional `ddlBESearchType` options, but they are internal tools (a name-reservation availability checker and an internal charter-number relookup) rather than independent public search axes with their own confirmed field mapping; excluded from v1 to avoid shipping an unverified mode.
- **Filing/document history** — the detail page does not expose a list of individual filed documents; only the current entity snapshot (type, status, dates, addresses, agent) is available for free.
- **Report-due date** — present on the source detail page for some entity types only; when absent for a given entity, the field is omitted rather than left null.

### Output per entity

- `entityName`
- `charterNumber` — Missouri's entity identifier (e.g. `F01326154`)
- `entityType` — e.g. `Gen. Business - For Profit`, `Domestic Limited Liability Company`
- `status` — e.g. `Good Standing`, `Admin Diss/Cancel - Agent`
- `domesticity` — `Domestic` or `Foreign`
- `homeState` — state/country of origin for foreign entities
- `dateFormed` — `YYYY-MM-DD`
- `duration` — e.g. `Perpetual`
- `reportDue` — when on file
- `principalAddress`
- `registeredAgentName`, `registeredAgentId`, `registeredAgentAddress`
- `internalId` — Missouri's internal record ID (used to build `sourceUrl`)
- `sourceUrl`
- `recordType: "entity"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byBusinessName` | `byBusinessName` / `byRegisteredAgent` |
| `searchTerm` | string | `AMAZON` | Business name or registered agent name to search for |
| `nameSearchMethod` | string | `startingWith` | `startingWith` / `allWords` / `anyWord` / `exactMatch` |
| `activeOnly` | boolean | `false` | Restrict to active/good-standing entities only |
| `proxyConfiguration` | object | AUTO proxy | Apify proxy config; always datacenter (AUTO), never residential |
| `maxItems` | int | `25` | Hard cap (1–200) |

#### Example: search by business name prefix

```json
{
  "mode": "byBusinessName",
  "searchTerm": "TESLA",
  "nameSearchMethod": "startingWith",
  "maxItems": 10
}
````

#### Example: search by registered agent, active entities only

```json
{
  "mode": "byRegisteredAgent",
  "searchTerm": "Corporation Service Company",
  "nameSearchMethod": "allWords",
  "activeOnly": true,
  "maxItems": 25
}
```

#### Example: exact business name match

```json
{
  "mode": "byBusinessName",
  "searchTerm": "AMAZON CAPITAL SERVICES, INC.",
  "nameSearchMethod": "exactMatch",
  "maxItems": 5
}
```

### Use cases

- **Due diligence** — confirm a counterparty's Missouri formation date, entity type, and registered agent before contracting
- **Compliance & KYC** — cross-check a business's legal entity name and charter number
- **Registered agent research** — find every entity a specific agent represents in Missouri
- **Company name availability checks** — see what similarly-named entities already exist before choosing a new name
- **Market research** — pull active entities matching a brand or franchise name

### FAQ

**What's the data source?** The Missouri Secretary of State's own free public Business Entity Search at `bsd.sos.mo.gov`. This actor is an independent third-party tool and is not affiliated with the State of Missouri.

**Is this data official / legally binding?** No. For an official Certificate of Good Standing or certified copies, use the state's paid ordering channels (see the source site). This actor returns the same free-tier informational data the public search page shows.

**Why did my run return 0 results?** Either the query genuinely has no match, or the match method (starting with / all words / any word / exact match) is narrower than expected. Try a broader match method.

**Why did my run take longer than expected?** Missouri's Cloudflare protection occasionally denies a fraction of Apify's shared datacenter IPs. The actor automatically retries with fresh proxy sessions until it succeeds, which can add latency on an unlucky run, but does not require any paid proxy or manual intervention.

**What's the difference between the match methods?** `Starting with` matches the beginning of the name; `All words` requires every search word to appear; `Any word` matches if any search word appears; `Exact match` requires the full name. These mirror Missouri's own search form options exactly.

**How fresh is the data?** Real-time — the search reflects the Secretary of State's database as of the moment of the search.

# Actor input Schema

## `mode` (type: `string`):

Which search axis to use.

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

Business name (mode=byBusinessName) or registered agent name (mode=byRegisteredAgent) to search for, e.g. `AMAZON`.

## `nameSearchMethod` (type: `string`):

How `searchTerm` is matched against entity/agent names.

## `activeOnly` (type: `boolean`):

Restrict results to active/good-standing corporations only.

## `proxyConfiguration` (type: `object`):

Uses Apify's free datacenter (AUTO) proxy group to get a fresh IP when a request is temporarily blocked. Residential proxy is never used by this actor.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "byBusinessName",
  "searchTerm": "AMAZON",
  "nameSearchMethod": "startingWith",
  "activeOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 10
}
```

# Actor output Schema

## `entities` (type: `string`):

Dataset containing all scraped Missouri business entity records.

# 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 = {
    "mode": "byBusinessName",
    "searchTerm": "AMAZON",
    "nameSearchMethod": "startingWith",
    "activeOnly": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/missouri-sos-business-search-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 = {
    "mode": "byBusinessName",
    "searchTerm": "AMAZON",
    "nameSearchMethod": "startingWith",
    "activeOnly": False,
    "proxyConfiguration": { "useApifyProxy": True },
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/missouri-sos-business-search-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 '{
  "mode": "byBusinessName",
  "searchTerm": "AMAZON",
  "nameSearchMethod": "startingWith",
  "activeOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxItems": 10
}' |
apify call crawlerbros/missouri-sos-business-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Missouri Secretary of State Business Search Scraper",
        "description": "Search Missouri's free public Business Entity Search (bsd.sos.mo.gov) by business name or registered agent name. Get entity type, status, charter number, formation date, principal address, registered agent, and more.",
        "version": "1.0",
        "x-build-id": "8GqjgWLG55q2LHlXY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~missouri-sos-business-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-missouri-sos-business-search-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/crawlerbros~missouri-sos-business-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-missouri-sos-business-search-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/crawlerbros~missouri-sos-business-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-missouri-sos-business-search-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",
                "required": [
                    "mode",
                    "searchTerm",
                    "proxyConfiguration"
                ],
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "byBusinessName",
                            "byRegisteredAgent"
                        ],
                        "type": "string",
                        "description": "Which search axis to use.",
                        "default": "byBusinessName"
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Business name (mode=byBusinessName) or registered agent name (mode=byRegisteredAgent) to search for, e.g. `AMAZON`.",
                        "default": "AMAZON"
                    },
                    "nameSearchMethod": {
                        "title": "Name match method",
                        "enum": [
                            "startingWith",
                            "allWords",
                            "anyWord",
                            "exactMatch"
                        ],
                        "type": "string",
                        "description": "How `searchTerm` is matched against entity/agent names.",
                        "default": "startingWith"
                    },
                    "activeOnly": {
                        "title": "Active corporations only",
                        "type": "boolean",
                        "description": "Restrict results to active/good-standing corporations only.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Uses Apify's free datacenter (AUTO) proxy group to get a fresh IP when a request is temporarily blocked. Residential proxy is never used by this actor.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```