# Campaign Finance Monitor (`b3lch/campaign-finance-monitor`) Actor

Ticker-first feed of US federal campaign contributions from the employees and corporate PACs of given public companies — sourced from FEC Schedule A, enriched with the recipient candidate, office, and party. Corporate political exposure as a clean, auditable feed.

- **URL**: https://apify.com/b3lch/campaign-finance-monitor.md
- **Developed by:** [alfred dias](https://apify.com/b3lch) (community)
- **Categories:** Business, News
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

### What does the Campaign Finance Monitor do?

The Campaign Finance Monitor turns the FEC's public Schedule A filings into a single, clean, ticker-first feed of US federal campaign contributions flowing **from** the employees and corporate PACs of the public companies you name. Input a list of tickers (or company names) and a date window; the Actor resolves each company to its SEC-registered identity, queries the FEC OpenFEC API for itemized contributions whose `contributor_employer` matches, enriches every row with the recipient candidate, office, party, and state, and tags it with the input company's ticker — corporate political exposure as a clean, auditable feed.

Use it to follow the money around specific tickers (e.g. `["AAPL","MSFT"]`), or run it wider across a watchlist. Because it runs as an Apify Actor, you can schedule it (for example monthly across a two-year cycle) and pipe new rows into Slack, email, webhooks, Zapier, Make, or your data warehouse via Apify's integrations — no scraping code required.

### Why use it?

- **Precision-first employer→ticker attribution** — the core differentiator. The Actor matches `contributor_employer` against authoritative SEC-registered name variants only, then re-validates each returned record. It is deliberately conservative: it would rather miss a messy spelling than attribute a donation to the wrong company. "Apple Inc." matches Apple; "Applebee's" never does.
- **Corporate political exposure for ESG, risk, and journalism** — see which candidates and parties a company's workforce and PAC are funding, across an entire cycle, without hand-querying the FEC.
- **A "follow the money" trilogy** — pairs with `sec-insider-trading` (insider trades) and `biotech-catalyst-monitor` (regulatory catalysts) for a unified public-disclosure intelligence stack.

### How to use it

1. Click **Try for free**.
2. Enter one or more tickers or company names in `companies` (e.g. `["AAPL","MSFT"]`).
3. Optionally narrow the window with `dateFrom` / `dateTo`, cap volume with `maxResults`, or filter recipients with `offices` / `parties`.
4. Set `contactEmail` (used in the User-Agent sent to the FEC) and, for anything beyond a trial, your own `fecApiKey`.
5. Click **Start**, then open the **Dataset** tab to download JSON, CSV, or Excel — or connect via the API. Schedule recurring runs to accumulate a rolling cycle.

### Input

- `companies` *(array, required)* — public-company tickers or names, e.g. `["AAPL","Tesla"]`.
- `dateFrom` / `dateTo` *(string, YYYY-MM-DD)* — contribution receipt-date window. Defaults: start of the current FEC two-year cycle → today.
- `maxResults` *(integer)* — per-company cap on returned contributions. Default `1000`.
- `offices` *(array)* — filter recipients by the office they seek: `PRESIDENT`, `SENATE`, `HOUSE`. Empty = all.
- `parties` *(array)* — filter recipients by party (e.g. `DEM`, `REP`). Empty = all.
- `fecApiKey` *(string)* — your **free** FEC OpenFEC API key. The `DEMO_KEY` default works for trials but is heavily rate-limited (~30 calls/hour); sign up at the FEC developer portal for the standard 1,000 calls/hour allotment.
- `contactEmail` *(string, required)* — used in the User-Agent header. The FEC asks for a descriptive User-Agent with a real contact; use a mailbox you monitor.

### Output

Each dataset item is one itemized contribution, enriched with the recipient candidate and the input company's ticker. Example:

```json
{
    "ticker": "AAPL",
    "company": "Apple Inc",
    "matchMethod": "employer",
    "contributionType": "Individual",
    "donorName": "Priya Sharma",
    "donorEmployer": "Apple Inc.",
    "donorOccupation": "Software Engineer",
    "amount": 2900.00,
    "receiptDate": "2025-09-14",
    "recipientCommittee": "Aldridge for Senate",
    "recipientCommitteeId": "C00800001",
    "committeeType": "Campaign",
    "recipientCandidate": "Daniel Aldridge",
    "office": "S",
    "party": "DEM",
    "state": "CA",
    "incumbent": "Challenger",
    "cycle": 2026,
    "isAmendment": false,
    "source": "FEC",
    "fecUrl": "https://www.fec.gov/data/committee/C00800001/",
    "rowHash": "a1b2c3d4e5f6a7b8"
}
````

A `SUMMARY` record is written to the run's key-value store with run-level metadata: `companiesRequested`, `rowsCount`, `contributionsSeen`, `dedupedAmendments`, `dateFrom`, `dateTo`, `fecPageCapHit`, `fecRateLimited`, `fecError`, and `unresolvedCompanies`. Check it when a run returns fewer rows than expected.

### Data fields

| Field | Type | Description |
| --- | --- | --- |
| `ticker` | string | Resolved input company ticker. |
| `company` | string | Canonical company name (SEC-registered). |
| `matchMethod` | string | How the contribution was attributed: `employer` (individual, employer-field match) or `pac` (company-sponsored PAC committee). |
| `contributionType` | string | `Individual`, `CorpPAC`, or `Other`. |
| `donorName` | string | Contributor name as filed on Schedule A. |
| `donorEmployer` | string | Raw `contributor_employer` as filed. |
| `donorOccupation` | string | Raw `contributor_occupation` as filed. |
| `amount` | number | Contribution receipt amount (USD). |
| `receiptDate` | string | Contribution receipt date (ISO). |
| `recipientCommittee` | string | Recipient committee name. |
| `recipientCommitteeId` | string | FEC committee ID. |
| `committeeType` | string | Committee type, full (e.g. `PAC`, `Campaign`, `Party`). |
| `recipientCandidate` | string | Linked candidate name; `null` for non-candidate committees (PAC-only, party-only). |
| `office` | string | Office sought: `P`, `S`, or `H`; `null` when no candidate is linked. |
| `party` | string | Candidate party (e.g. `DEM`, `REP`); `null` when not applicable. |
| `state` | string | Candidate state; `null` when not applicable. |
| `incumbent` | string | `Incumbent`, `Challenger`, or `Open`; `null` when not reported. |
| `cycle` | integer | Two-year transaction period (e.g. `2026`). |
| `isAmendment` | boolean | `true` if the record comes from an amended or superseded filing. |
| `source` | string | Always `FEC`. |
| `fecUrl` | string | Human-readable link to the committee or filing on FEC.gov. |
| `rowHash` | string | Dedupe key (donor + amount + date + committee + cycle). |

### Pricing

This Actor uses Apify's **pay-per-result** pricing model with a free tier included, so you can try it at no cost before scaling up. Indicative rate: ~$0.01 per contribution row plus a ~$0.02 run-start fee. See the Pricing tab on this page for current rates.

### FAQ, disclaimers, and support

**Federal only — no state or local finance.** The FEC covers US federal candidates and committees only. State and local campaign finance lives in 50+ separate systems and is out of scope for v1.

**Why am I not seeing small individual contributions?** The FEC itemizes individual contributions only above its reporting threshold (roughly $200/cycle aggregated per recipient). Smaller individual gifts appear in aggregate totals, not as distinct rows. Corporate PAC contributions are always itemized.

**Why might a known employee contribution be missing?** Employer matching is precision-first: the Actor validates each record's `contributor_employer` against SEC-registered name variants and rejects ambiguous or common-word matches. A genuinely messy employer spelling may be missed rather than risk attributing a donation to the wrong company. This tradeoff is the product's core promise.

**Why do PAC contributions disappear when I filter by `offices`?** By design. The `offices` filter acts on the recipient *candidate's* office. PAC-only contributions go to committees with no linked candidate, so they carry `office: null` and are excluded whenever an office filter is active. Leave `offices` empty to retain PAC rows.

**Do I need an FEC API key?** The `DEMO_KEY` default works for trials but is heavily rate-limited (~30 calls/hour). For anything larger, sign up free at the FEC developer portal and pass your key as `fecApiKey` for the standard 1,000 calls/hour allotment. A 7,200/hour tier is available from the FEC for heavy users.

**How current is the data, and how are amendments handled?** As current as the FEC's own filings. Amended filings supersede originals; the Actor dedupes superseded records and flags any remaining amended rows with `isAmendment: true`. Run-level warnings (`fecRateLimited`, `fecPageCapHit`, `fecError`) appear in the `SUMMARY` key-value store.

**Is this investment or legal advice?** No. This Actor is a data-aggregation tool over public FEC filings. Nothing it outputs is a recommendation to buy, sell, or hold any security, or a substitute for your own due diligence. Always verify against the linked `fecUrl` before acting.

**Something looks wrong or missing.** Please open an issue on the Actor's Issues tab with the run ID and what you expected — we read every report.

# Actor input Schema

## `companies` (type: `array`):

Public-company tickers or names (e.g. \["AAPL","Tesla"]). Returns US federal campaign contributions from their employees and corporate PACs.

## `dateFrom` (type: `string`):

Earliest contribution receipt date (YYYY-MM-DD). Default: start of the current two-year FEC cycle.

## `dateTo` (type: `string`):

Latest contribution receipt date (YYYY-MM-DD). Default: today.

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

Maximum contributions to return per company. Bounds cost and the FEC rate limit.

## `offices` (type: `array`):

Filter recipients by the office they seek.

## `parties` (type: `array`):

Filter recipients by party (e.g. DEM, REP). Empty = all.

## `fecApiKey` (type: `string`):

Your free FEC OpenFEC API key (sign up at the FEC developer portal). The DEMO\_KEY default works for trials but is heavily rate-limited (~30 calls/hour); a personal key raises that to the standard 1,000 calls/hour.

## `contactEmail` (type: `string`):

Used in the User-Agent header sent to the FEC. The FEC requires a descriptive User-Agent with a real contact; use a mailbox you monitor.

## Actor input object example

```json
{
  "companies": [],
  "maxResults": 1000,
  "offices": [],
  "parties": [],
  "fecApiKey": "DEMO_KEY"
}
```

# Actor output Schema

## `dataset` (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 = {
    "companies": [],
    "offices": [],
    "parties": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("b3lch/campaign-finance-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "companies": [],
    "offices": [],
    "parties": [],
}

# Run the Actor and wait for it to finish
run = client.actor("b3lch/campaign-finance-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [],
  "offices": [],
  "parties": []
}' |
apify call b3lch/campaign-finance-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=b3lch/campaign-finance-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Campaign Finance Monitor",
        "description": "Ticker-first feed of US federal campaign contributions from the employees and corporate PACs of given public companies — sourced from FEC Schedule A, enriched with the recipient candidate, office, and party. Corporate political exposure as a clean, auditable feed.",
        "version": "1.1",
        "x-build-id": "Ika581nxH7bwFWcwf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b3lch~campaign-finance-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b3lch-campaign-finance-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/b3lch~campaign-finance-monitor/runs": {
            "post": {
                "operationId": "runs-sync-b3lch-campaign-finance-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/b3lch~campaign-finance-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-b3lch-campaign-finance-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companies",
                    "contactEmail"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "Public-company tickers or names (e.g. [\"AAPL\",\"Tesla\"]). Returns US federal campaign contributions from their employees and corporate PACs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Earliest contribution receipt date (YYYY-MM-DD). Default: start of the current two-year FEC cycle."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Latest contribution receipt date (YYYY-MM-DD). Default: today."
                    },
                    "maxResults": {
                        "title": "Max results per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum contributions to return per company. Bounds cost and the FEC rate limit.",
                        "default": 1000
                    },
                    "offices": {
                        "title": "Recipient offices",
                        "type": "array",
                        "description": "Filter recipients by the office they seek.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PRESIDENT",
                                "SENATE",
                                "HOUSE"
                            ],
                            "enumTitles": [
                                "President",
                                "Senate",
                                "House"
                            ]
                        }
                    },
                    "parties": {
                        "title": "Recipient parties",
                        "type": "array",
                        "description": "Filter recipients by party (e.g. DEM, REP). Empty = all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fecApiKey": {
                        "title": "FEC API key",
                        "type": "string",
                        "description": "Your free FEC OpenFEC API key (sign up at the FEC developer portal). The DEMO_KEY default works for trials but is heavily rate-limited (~30 calls/hour); a personal key raises that to the standard 1,000 calls/hour.",
                        "default": "DEMO_KEY"
                    },
                    "contactEmail": {
                        "title": "Contact email",
                        "type": "string",
                        "description": "Used in the User-Agent header sent to the FEC. The FEC requires a descriptive User-Agent with a real contact; use a mailbox you monitor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
