# MCP: Accounting Firm Leads - AI Agents/Claude/GPT (`seibs.co/mcp-accounting-firm-leads`) Actor

MCP server exposing US accounting / CPA / bookkeeping / payroll / fractional CFO leads to AI agents (Claude, GPT, LangChain, Lindy, Crew.ai). 5 tools: search, single-firm lookup, filter by tech stack (QuickBooks/Karbon/TaxDome), by specialty, by modern\_score.

- **URL**: https://apify.com/seibs.co/mcp-accounting-firm-leads.md
- **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## MCP: Accounting Firm Leads - AI Agents / Claude / GPT

A Model Context Protocol (MCP) server exposing US accounting / CPA /
bookkeeping / payroll / fractional CFO lead intelligence to AI agents.
Wraps `Seibs.Co/accounting-firm-lead-finder` with an agent-callable
interface so Claude, GPT, LangChain, Lindy, Crew.ai, and custom LLM
workflows can fetch enriched firm records on-demand.

### What is MCP?

[Model Context Protocol](https://modelcontextprotocol.io) is Anthropic's
open standard for letting AI agents discover and call external tools.
Instead of stuffing scraping logic into every agent, you expose
capabilities as MCP tools and the agent invokes them by name with
typed arguments. This actor implements an Apify-hosted MCP server
that an agent can reach over HTTPS.

### The 5 tools

| Tool | Purpose |
|---|---|
| `search_accounting_firms` | Broad Google Maps lookup. Args: `locations`, `search_terms`, `max_results`. |
| `get_firm_intel` | Single firm deep-dive. Args: `business_name`, `location`. |
| `find_firms_by_tech_stack` | Filter by detected software (QuickBooks, Xero, Karbon, TaxDome, Lacerte, Drake, ProConnect, UltraTax, Canopy, Jetpack, Liscio, Bill.com). Args: `software`, `locations`, `max_results`. |
| `find_firms_by_specialty` | Filter by practice type: `tax`, `bookkeeping`, `audit`, `advisory`, `payroll`, `cfo_services`, `forensic`, `estate`, `enrolled_agent`, `wealth`. |
| `find_modern_firms` | Surface cloud-stack modern firms. Args: `locations`, `min_modern_score` (0-1, default 0.6). |

Each record returned includes name, address, phone, website,
decision-maker emails, detected tech stack, modern_score, and
service lines.

### How AI agents consume this

#### 1. Discover tools (free, no charge)

```bash
curl -X POST "https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"action": "list_tools"}'
````

Returns `{ protocolVersion, server, tools: [...] }` - the full MCP
tool catalog. Agent caches this and uses it to construct tool calls.

#### 2. Invoke a tool

```bash
curl -X POST "https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "find_firms_by_tech_stack",
    "args": {
      "software": ["karbon", "taxdome"],
      "locations": ["Austin, TX", "Denver, CO"],
      "max_results": 25
    }
  }'
```

Response includes the MCP-shaped envelope:

```json
{
  "tool": "find_firms_by_tech_stack",
  "mcp_response": {
    "isError": false,
    "content": [
      {"type": "text", "text": "Top matches: ..."},
      {"type": "json", "json": [{"name": "...", "website": "...", "decision_maker_emails": [...]}]}
    ]
  },
  "results": [ ... ],
  "result_count": 17
}
```

### Integration snippets

#### Claude (Anthropic SDK, tool-use)

```python
import anthropic, httpx

APIFY_TOKEN = "..."
ANTHROPIC = anthropic.Anthropic()

def mcp_tool_call(tool: str, args: dict) -> dict:
    r = httpx.post(
        f"https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={APIFY_TOKEN}",
        json={"tool": tool, "args": args}, timeout=600,
    )
    return r.json()[0]

## Register the 5 tools with Claude (fetch schemas once via list_tools).
tools = mcp_tool_call("list_tools", {})["mcp_response"]["tools"]
claude_tools = [
    {"name": t["name"], "description": t["description"], "input_schema": t["inputSchema"]}
    for t in tools
]

resp = ANTHROPIC.messages.create(
    model="claude-opus-4-5",
    max_tokens=4096,
    tools=claude_tools,
    messages=[{"role": "user", "content": "Find 10 CPAs in Austin that use Karbon."}],
)
## When resp.stop_reason == "tool_use", call mcp_tool_call(...) and feed back.
```

#### LangChain

```python
from langchain.tools import StructuredTool
import httpx

def make_mcp_tool(name, desc, schema):
    def _run(**kwargs):
        r = httpx.post(
            f"https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={APIFY_TOKEN}",
            json={"tool": name, "args": kwargs}, timeout=600,
        )
        return r.json()[0]["results"]
    return StructuredTool.from_function(name=name, description=desc, func=_run)
```

#### Lindy

In Lindy, add a Custom Action -> HTTP Request:

- Method: `POST`
- URL: `https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={{secrets.APIFY_TOKEN}}`
- Body: `{ "tool": "{{tool_name}}", "args": {{args_json}} }`
- Map the response.results into your workflow.

#### Crew.ai

```python
from crewai_tools import tool
import httpx

@tool("find_accounting_firms")
def find_accounting_firms(locations: list[str], software: list[str]) -> list[dict]:
    """Find US accounting firms using specific software."""
    r = httpx.post(
        f"https://api.apify.com/v2/acts/Seibs.Co~mcp-accounting-firm-leads/run-sync-get-dataset-items?token={APIFY_TOKEN}",
        json={"tool": "find_firms_by_tech_stack", "args": {
            "software": software, "locations": locations, "max_results": 25
        }}, timeout=600,
    )
    return r.json()[0]["results"]
```

### Pricing

- `$0.005` per MCP tool call (this actor).
- Plus pass-through of the underlying `accounting-firm-lead-finder` PPE
  charges (`~$0.015` per premium record). A search returning 25 leads
  costs roughly `$0.005 + 25 * $0.015 = $0.38`.

### Limits / notes

- Each tool call runs the upstream actor once. Cold-start latency is
  the upstream's latency (15s - 2min depending on query size).
- `find_firms_by_tech_stack` and `find_modern_firms` use client-side
  filtering on the upstream results, so they may return fewer records
  than `max_results` if the filter is strict. The wrapper casts a
  wider upstream net (3-4x) to compensate.
- All filtering uses the upstream record's `detected_tech` and
  `modern_score` fields. Underlying detection accuracy is what it is.

### Underlying actor

[`Seibs.Co/accounting-firm-lead-finder`](https://apify.com/Seibs.Co/accounting-firm-lead-finder)

### Contact

- Email: jtseib@live.com

### Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with a single click - no need to re-type search terms, locations, filters, or tier settings every time. Tasks are the foundation for everything that comes next: schedules, monitor mode, and webhook routing all attach to a saved Task, not to the raw actor.

Steps to save your current input as a Task:

1. On this actor's Apify Store page, click `Run` with your input fully configured.
2. Click the `Save as task` button at the top of the run page.
3. Name the task something memorable (e.g. `Saved CPA query for agent - on-demand`).
4. Reload the task page and click `Start` anytime to re-run with the same inputs.

Tasks unlock the next two features below: scheduling and monitor mode.

### Run this weekly with Apify Schedules

Apify Schedules cron-run any saved Task automatically. Pair this with the saved Task above and you get hands-off recurring runs with no manual clicks.

Steps to schedule a Task:

1. Save your input as a Task (see above).
2. Go to https://console.apify.com/schedules and click `Create new schedule`.
3. Pick your Task and set the cron expression. Common patterns:
   - Daily at 9am UTC: `0 9 * * *`
   - Weekly on Mondays at 9am: `0 9 * * 1`
   - Monthly on the 1st: `0 9 1 * *`
4. Save. Apify will run your Task on that schedule automatically, push the dataset to whatever integrations you have wired up, and fire run-completion webhooks.

Schedules are unusual for MCP wrappers because AI agents invoke them on-demand. Use Tasks for saved configs but skip the cron schedule unless you have a specific batch-run use case.

### Monitor mode (v2, beta)

Monitor mode is the v2 evolution of this actor and is currently in BETA. It turns a recurring schedule into a true change-feed instead of a firehose of duplicate records.

How it works:

- When this actor runs under an Apify Schedule, monitor mode is enabled automatically.
- Instead of emitting ALL records every run, it emits ONLY records that are NEW or CHANGED since the last scheduled run.
- A digest record summarizes the delta (X new, Y changed, Z removed) at the top of every run.
- Optional: provide a Slack or email webhook URL in the `monitor_webhook_url` input field and the digest fires there too, so your team gets the delta in their inbox or channel without polling the dataset.
- Cost: a single `scheduled_delta_run` event ($0.05) per scheduled run, plus standard PPE on emitted delta records only. Predictable monthly cost, no surprise bills from re-charging for unchanged records.

Monitor mode is rolling out to the top 3 actors first (this one included if it's hotel-motel-lead-finder, google-maps-reviews-pro, or mcp-accounting-firm-leads). Full portfolio coverage by end of June.

### Found this useful?

If this actor saved you time or money, please consider leaving a quick review on the Apify Store. Reviews help other buyers find work that solves their problem and let me prioritize the features paying customers actually use. Leave a review: https://apify.com/seibs.co/mcp-accounting-firm-leads#reviews

# Actor input Schema

## `action` (type: `string`):

Set to 'list\_tools' to receive the MCP tool catalog. Leave empty for normal tool invocation.

## `tool` (type: `string`):

Which tool to invoke.

## `args` (type: `object`):

Arguments for the selected tool. Shape depends on tool: search\_accounting\_firms { locations: \[], search\_terms: \[], max\_results }; get\_firm\_intel { business\_name, location }; find\_firms\_by\_tech\_stack { software: \[], locations: \[], max\_results }; find\_firms\_by\_specialty { specialty: \[], locations: \[], max\_results }; find\_modern\_firms { locations: \[], min\_modern\_score, max\_results }.

## Actor input object example

```json
{
  "action": "",
  "tool": "search_accounting_firms",
  "args": {
    "locations": [
      "Austin, TX"
    ],
    "search_terms": [
      "cpa",
      "bookkeeping"
    ],
    "max_results": 25
  }
}
```

# 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 = {
    "tool": "search_accounting_firms",
    "args": {
        "locations": [
            "Austin, TX"
        ],
        "search_terms": [
            "cpa",
            "bookkeeping"
        ],
        "max_results": 25
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("seibs.co/mcp-accounting-firm-leads").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 = {
    "tool": "search_accounting_firms",
    "args": {
        "locations": ["Austin, TX"],
        "search_terms": [
            "cpa",
            "bookkeeping",
        ],
        "max_results": 25,
    },
}

# Run the Actor and wait for it to finish
run = client.actor("seibs.co/mcp-accounting-firm-leads").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 '{
  "tool": "search_accounting_firms",
  "args": {
    "locations": [
      "Austin, TX"
    ],
    "search_terms": [
      "cpa",
      "bookkeeping"
    ],
    "max_results": 25
  }
}' |
apify call seibs.co/mcp-accounting-firm-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=seibs.co/mcp-accounting-firm-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MCP: Accounting Firm Leads - AI Agents/Claude/GPT",
        "description": "MCP server exposing US accounting / CPA / bookkeeping / payroll / fractional CFO leads to AI agents (Claude, GPT, LangChain, Lindy, Crew.ai). 5 tools: search, single-firm lookup, filter by tech stack (QuickBooks/Karbon/TaxDome), by specialty, by modern_score.",
        "version": "0.1",
        "x-build-id": "YRn40RaWtB4vWFh43"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seibs.co~mcp-accounting-firm-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seibs.co-mcp-accounting-firm-leads",
                "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/seibs.co~mcp-accounting-firm-leads/runs": {
            "post": {
                "operationId": "runs-sync-seibs.co-mcp-accounting-firm-leads",
                "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/seibs.co~mcp-accounting-firm-leads/run-sync": {
            "post": {
                "operationId": "run-sync-seibs.co-mcp-accounting-firm-leads",
                "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": [
                    "tool"
                ],
                "properties": {
                    "action": {
                        "title": "Action (optional)",
                        "enum": [
                            "",
                            "list_tools"
                        ],
                        "type": "string",
                        "description": "Set to 'list_tools' to receive the MCP tool catalog. Leave empty for normal tool invocation.",
                        "default": ""
                    },
                    "tool": {
                        "title": "MCP tool name",
                        "enum": [
                            "search_accounting_firms",
                            "get_firm_intel",
                            "find_firms_by_tech_stack",
                            "find_firms_by_specialty",
                            "find_modern_firms"
                        ],
                        "type": "string",
                        "description": "Which tool to invoke.",
                        "default": "search_accounting_firms"
                    },
                    "args": {
                        "title": "Tool arguments (JSON object)",
                        "type": "object",
                        "description": "Arguments for the selected tool. Shape depends on tool: search_accounting_firms { locations: [], search_terms: [], max_results }; get_firm_intel { business_name, location }; find_firms_by_tech_stack { software: [], locations: [], max_results }; find_firms_by_specialty { specialty: [], locations: [], max_results }; find_modern_firms { locations: [], min_modern_score, max_results }.",
                        "default": {
                            "locations": [
                                "Austin, TX"
                            ],
                            "search_terms": [
                                "cpa",
                                "bookkeeping"
                            ],
                            "max_results": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```