# Fundraising Scraper: Startup Funding Rounds Tracker (`trovevault/startup-funding-rounds-tracker`) Actor

Track recent startup funding rounds. Export company names, announcement dates, funding amounts, round stages, investors, categories, and regions.

- **URL**: https://apify.com/trovevault/startup-funding-rounds-tracker.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Lead generation, Jobs, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 startups

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

## Fundraising Scraper: Startup Funding Rounds Tracker

Track recent startup funding round announcements and export clean funded-company rows for lead generation, market research, investor mapping, and CRM enrichment. The Actor returns company names, announcement dates, funding amounts, parsed USD amounts, round stages, investors, categories, and regions when those details appear in public funding news.

### What does this Fundraising Scraper do?

This Actor monitors public startup funding news feeds and converts funding announcements into structured records. It is designed for repeat workflows where fresh capital is the buying signal: sales teams looking for newly funded accounts, recruiters watching hiring windows, agencies building prospect lists, and investors tracking active sectors.

The Actor extracts:

| Field | Meaning |
|---|---|
| `companyName` | Startup or company named in the funding announcement |
| `announcementDate` | Publication date of the announcement |
| `fundingAmount` | Funding amount as published, such as `$130M` |
| `fundingAmountUsd` | Parsed USD amount when the announcement uses USD |
| `fundingRound` | Round stage such as Seed, Series A, Series B, Growth, Grant, or Debt |
| `leadInvestors` | Investors named as leading or co-leading the round |
| `participatingInvestors` | Other named backers or participants |
| `companyCategory` | Buyer-facing category or sector tag |
| `region` | Detected location, country, or market when present |

The public dataset does not include raw source URLs, source names, scrape timestamps, debug notes, or confidence fields. Operational details are stored in `RUN_SUMMARY` so downstream users get a clean table.

### Why use this Actor?

Funding announcements are time-sensitive. A company that just raised a Seed, Series A, or growth round may be hiring, expanding sales, buying infrastructure, or choosing vendors. Manually checking funding news every day is slow and easy to miss; this Actor gives you a scheduled, exportable feed of recent funded companies.

Use it to:

- Build CRM lists of recently funded companies.
- Track investors and sectors that are active this week.
- Find companies likely to expand headcount or vendor spend.
- Monitor startup funding momentum by category or market.
- Feed downstream enrichment, outreach, or reporting pipelines.

### How is it different from a raw funding news scraper?

The Actor is intentionally shaped as a funded-company tracker, not a raw article exporter. It filters for funding language, deduplicates announcements, parses round and investor signals, and keeps output fields focused on the buyer decision. Rows are suitable for CSV export, API use, scheduled monitoring, or enrichment pipelines.

It does not try to expose every article field. If a public article does not name a lead investor, participating investors, or region, the Actor leaves that part empty instead of guessing.

### How do I run it?

1. Choose a `dateRange`, such as `last_7_days`.
2. Optionally add `stages` such as `Seed`, `Series A`, or `Series B`.
3. Optionally set `minFundingAmount` in USD.
4. Run the Actor and export the default dataset as JSON, CSV, Excel, or through the Apify API.

Example input:

```json
{
  "dateRange": "last_90_days",
  "stages": ["Seed", "Series A", "Series B", "Series C", "Growth"],
  "minFundingAmount": 10000000,
  "maxResults": 50
}
````

### What input does it accept?

| Input | Type | Required | Description |
|---|---:|---:|---|
| `dateRange` | string | yes | Recency window: `today`, `last_3_days`, `last_7_days`, `last_30_days`, `last_90_days`, `last_180_days`, or `last_365_days`. |
| `stages` | string array | no | Funding stages to keep from the dropdown, such as `Seed`, `Series A`, `Series B`, `Growth`, `Grant`, `Debt`, or `Undisclosed`. |
| `minFundingAmount` | integer | no | Minimum parsed USD amount. Non-USD or undisclosed amounts are kept only when this is empty. |
| `maxResults` | integer | no | Maximum returned rows after filters and deduplication. Default: `50`. |
| `datasetId` | string | no | Existing Apify dataset ID for appending rows in addition to the default dataset. |
| `runId` | string | no | External workflow ID stored in `RUN_SUMMARY` for pipeline tracking. |

### What data does it return?

Example output row:

```json
{
  "companyName": "Prime Intellect",
  "announcementDate": "2026-07-08",
  "fundingAmount": "$130M",
  "fundingAmountUsd": 130000000,
  "fundingRound": "Series A",
  "leadInvestors": ["Radical Ventures"],
  "participatingInvestors": [],
  "companyCategory": "AI",
  "region": "United States"
}
```

Investor fields are arrays because rounds can be led or backed by multiple firms. If the article only says that unnamed investors participated, the Actor does not invent names.

### How can I integrate it?

Run the Actor through the Apify API and fetch dataset items:

```bash
curl "https://api.apify.com/v2/acts/trovevault~startup-funding-rounds-tracker/run-sync-get-dataset-items" \
  -X POST \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "dateRange": "last_7_days",
    "stages": ["Seed", "Series A", "Series B"],
    "maxResults": 25
  }'
```

For scheduled monitoring, run the Actor daily with `dateRange` set to `today` or weekly with `last_7_days`. Use Apify integrations, webhooks, or MCP-enabled workflows to send the resulting dataset into your CRM, spreadsheet, warehouse, or internal alerting system.

If you already have a target dataset, provide `datasetId`. The Actor writes to its default dataset and appends the same rows to the provided dataset.

### Limitations

This Actor reads public funding news surfaces. It cannot extract details that are not published in the accessible article text, and it does not claim complete coverage of every global startup funding round.

Current limitations:

- Non-USD amounts are returned as published, but `fundingAmountUsd` is only filled when the amount is stated in USD.
- Investor parsing depends on wording such as `led by`, `co-led by`, `participation from`, or `backers included`.
- `fundingRound` is set to `Undisclosed` and `region` is set to `Not disclosed` when the article does not publish those details clearly.
- Some funding news is broad market analysis rather than one clean company announcement; the Actor filters these conservatively.
- Public sources can change feed format or temporarily block automated access.
- The Actor is not legal, investment, or financial advice.

### Troubleshooting

| Issue | Likely cause | Solution |
|---|---|---|
| No rows returned | Filters are too narrow or no recent announcements match the selected window | Use `last_30_days`, remove stage filters, or remove `minFundingAmount` for a broader run |
| Missing investors | The article did not name lead or participating investors in parseable wording | Keep the row for company and round tracking, or enrich the company separately |
| Missing USD amount | The article used a non-USD amount, undisclosed amount, or valuation-only wording | Remove `minFundingAmount` if you want to keep non-USD and undisclosed rounds |
| Too many broad market rows | The date range includes analysis articles with multiple companies | Add specific `stages` or a higher `minFundingAmount` |
| A source fails internally | A public feed changed or blocked the request | Check `RUN_SUMMARY`; successful feeds can still produce rows |

### FAQ

#### Can I schedule this Actor?

Yes. A daily schedule with `dateRange` set to `today` is useful for fresh lead alerts. A weekly schedule with `last_7_days` is better for CRM batch updates.

#### Does it include source URLs?

No. The dataset is designed as a clean funded-company table. Source diagnostics stay in `RUN_SUMMARY`; public rows focus on the business fields users act on.

#### Does it guarantee every funding round?

No. It tracks accessible public funding news and extracts rows when the announcement text contains enough structure. For complete financial databases, use this Actor as a lead-generation and monitoring layer, not as an audited market database.

#### Can I filter by investor?

The v1 Actor returns lead and participating investors when detected. Investor-name filtering can be added later if the output proves useful in live runs.

#### Can I use it with MCP or other agents?

Yes. Apify Actors can be called from agent workflows, and this Actor returns predictable dataset fields suitable for lead routing, enrichment, or alert generation.

#### Is the data safe for outreach?

Use the dataset as a starting point. Funding news is public, but outreach compliance depends on your jurisdiction, channel, CRM data, and consent rules.

### Changelog

- `0.1` - Initial TroveVault build with date/stage/minimum amount filters, investor extraction, optional dataset integration, and clean funded-company output.

# Actor input Schema

## `dateRange` (type: `string`):

Controls how far back the actor keeps funding announcements by publication date. Use today for daily lead checks, last\_7\_days for weekly prospecting, last\_90\_days for quarterly research, or last\_365\_days for annual market scans. Default: last\_7\_days.

## `stages` (type: `array`):

Optional funding stages to keep. Select one or more stages such as Seed, Series A, Growth, Debt, or Undisclosed. If omitted, the actor returns all detected stages, including rows where the announcement does not name a formal stage.

## `minFundingAmount` (type: `integer`):

Optional minimum funding amount in USD. Examples: 1000000, 10000000, 50000000. Rows with a lower parsed USD amount are removed; non-USD or undisclosed amounts are kept only when this field is empty.

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

Optional cap on returned rows after filters and deduplication. Use a smaller value for fast lead samples or scheduled smoke tests. Default: 50.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID. When provided, funding rows are appended there in addition to the default run dataset.

## `runId` (type: `string`):

Optional external run or workflow ID to include in RUN\_SUMMARY for pipeline tracking. It is not added to public dataset rows.

## Actor input object example

```json
{
  "dateRange": "last_7_days",
  "stages": [
    "Seed",
    "Series A",
    "Series B"
  ]
}
```

# Actor output Schema

## `datasetUrl` (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 = {
    "dateRange": "last_7_days",
    "stages": [
        "Seed",
        "Series A",
        "Series B"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/startup-funding-rounds-tracker").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 = {
    "dateRange": "last_7_days",
    "stages": [
        "Seed",
        "Series A",
        "Series B",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/startup-funding-rounds-tracker").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 '{
  "dateRange": "last_7_days",
  "stages": [
    "Seed",
    "Series A",
    "Series B"
  ]
}' |
apify call trovevault/startup-funding-rounds-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/startup-funding-rounds-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fundraising Scraper: Startup Funding Rounds Tracker",
        "description": "Track recent startup funding rounds. Export company names, announcement dates, funding amounts, round stages, investors, categories, and regions.",
        "version": "0.1",
        "x-build-id": "xbKBmyClajDgQKFBm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~startup-funding-rounds-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-startup-funding-rounds-tracker",
                "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/trovevault~startup-funding-rounds-tracker/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-startup-funding-rounds-tracker",
                "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/trovevault~startup-funding-rounds-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-startup-funding-rounds-tracker",
                "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": [
                    "dateRange"
                ],
                "properties": {
                    "dateRange": {
                        "title": "Date Range",
                        "enum": [
                            "today",
                            "last_3_days",
                            "last_7_days",
                            "last_30_days",
                            "last_90_days",
                            "last_180_days",
                            "last_365_days"
                        ],
                        "type": "string",
                        "description": "Controls how far back the actor keeps funding announcements by publication date. Use today for daily lead checks, last_7_days for weekly prospecting, last_90_days for quarterly research, or last_365_days for annual market scans. Default: last_7_days.",
                        "default": "last_7_days"
                    },
                    "stages": {
                        "title": "Funding Stages",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional funding stages to keep. Select one or more stages such as Seed, Series A, Growth, Debt, or Undisclosed. If omitted, the actor returns all detected stages, including rows where the announcement does not name a formal stage.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Pre-Seed",
                                "Seed",
                                "Post-Seed",
                                "Series A",
                                "Series A Extension",
                                "Series B",
                                "Series B Extension",
                                "Series C",
                                "Series D",
                                "Series E",
                                "Series F",
                                "Series G",
                                "Growth",
                                "Venture",
                                "Strategic",
                                "Grant",
                                "Debt",
                                "Convertible",
                                "Undisclosed"
                            ],
                            "enumTitles": [
                                "Pre-Seed",
                                "Seed",
                                "Post-Seed",
                                "Series A",
                                "Series A Extension",
                                "Series B",
                                "Series B Extension",
                                "Series C",
                                "Series D",
                                "Series E",
                                "Series F",
                                "Series G",
                                "Growth",
                                "Venture",
                                "Strategic",
                                "Grant",
                                "Debt",
                                "Convertible",
                                "Undisclosed"
                            ]
                        }
                    },
                    "minFundingAmount": {
                        "title": "Minimum Funding Amount",
                        "type": "integer",
                        "description": "Optional minimum funding amount in USD. Examples: 1000000, 10000000, 50000000. Rows with a lower parsed USD amount are removed; non-USD or undisclosed amounts are kept only when this field is empty."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Optional cap on returned rows after filters and deduplication. Use a smaller value for fast lead samples or scheduled smoke tests. Default: 50."
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID. When provided, funding rows are appended there in addition to the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional external run or workflow ID to include in RUN_SUMMARY for pipeline tracking. It is not added to public dataset rows."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
