# 🏛️ Congress Lobbying × Stock Trades Overlap (`seralifatih/congress-lobbying-trades-overlap`) Actor

Cross-references US federal lobbying filings (LDA) with Congressional stock trades (STOCK Act PTRs). One auditable record per member/quarter/sector overlap — trades, lobbying filings, committee links, disclosure lag. Every row traceable to filing IDs. Pairs with our Congress Trade Trackers.

- **URL**: https://apify.com/seralifatih/congress-lobbying-trades-overlap.md
- **Developed by:** [Fatih İlhan](https://apify.com/seralifatih) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / actor start

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

## Congress Lobbying × Trades Overlap

**Cross-reference US federal lobbying disclosures with Congressional stock trading disclosures — one auditable record per overlap.**

This actor joins two public disclosure systems that don't share keys: quarterly lobbying filings under the Lobbying Disclosure Act (LDA) and member stock transactions disclosed under the STOCK Act (PTR filings). It surfaces **same-quarter co-occurrence**: a member traded in sector X during a quarter in which sector X was the subject of lobbying activity — and, where the member sits on a committee with jurisdiction over that sector, it says so.

Every output row is traceable to specific filing IDs and source URLs. This is a records product: it reports what the filings say, in a form you can archive, query, and verify. It does not score, rank, or interpret.

> **An overlap is not a finding of wrongdoing.** Members of Congress trade securities and industries lobby Congress; both are legal, disclosed, and continuous. Co-occurrence within a quarter is a factual observation about two public datasets, nothing more. This actor makes no claim of causation and emits no trade recommendations.

Works as a companion to the [House Trading Pipeline](https://apify.com/seralifatih/congress-trading-pipeline-1) and the [Senate Trading Pipeline](https://apify.com/seralifatih/congress-trading-pipeline) — it reads their trade data directly, so records stay consistent across all three.

### What you get

One record per **(member, quarter, sector)** overlap — not one per trade, not one per filing. Each record bundles the full evidence on both sides:

```json
{
  "member_bioguide_id": "A000379",
  "member_name": "Mark Alford",
  "chamber": "house",
  "party": "R",
  "state": "MO",
  "quarter": "2026-Q1",
  "sector": "defense",
  "mapping_rule_id": "tk:LMT->defense",
  "mapping_confidence": "high",
  "overlap_type": "committee_match",
  "disclosure_lag_days": 30,
  "trades": [
    {
      "ptr_filing_id": "4d6016b4...",
      "ptr_url": "https://disclosures-clerk.house.gov/...",
      "ticker": "LMT",
      "transaction_type": "purchase",
      "amount_range": "$1,001 - $15,000",
      "transaction_date": "2026-01-05",
      "disclosure_date": "2026-02-04"
    }
  ],
  "lobbying": [
    {
      "lda_filing_uuid": "7866327b-c892-4430-b9f0-1f0f679c58c6",
      "lda_url": "https://lda.senate.gov/api/v1/filings/7866327b-.../",
      "registrant": "Example Government Affairs LLC",
      "client": "Example Defense Corp",
      "issue_codes": ["DEF", "BUD"],
      "amount_reported": 240000.0
    }
  ],
  "lobbying_filing_count": 38,
  "committees": [
    {
      "committee_id": "HSAS",
      "committee_name": "House Committee on Armed Services",
      "jurisdiction_tags": ["defense", "aerospace"],
      "is_subcommittee": false,
      "role": "Member"
    }
  ]
}
````

#### `overlap_type`

- **`committee_match`** — the member sits on at least one committee whose jurisdiction covers the overlap sector. The matched committee assignments are included as evidence.
- **`sector_match_only`** — the sector overlap exists, but no committee link does.

LDA filings disclose which chamber or agency was lobbied, not which committee — so committee matching is resolved through sector jurisdiction, and the record shows exactly which committee and which jurisdiction tag produced the match.

#### `lobbying_filing_count`

Popular sectors can attract over a thousand filings in a quarter, so the `lobbying[]` evidence list is capped (default 100, configurable) to the filings with the largest reported amounts. `lobbying_filing_count` always carries the uncapped total — truncation is visible on the record, never silent.

#### `disclosure_lag_days`

Days between a trade's transaction date and its public disclosure date (earliest trade in the record). A factual, derived field — the STOCK Act allows up to 45 days.

### The crosswalk is yours to audit

There is no official mapping between LDA issue codes, stock tickers, and committee jurisdictions. Every product in this space invents one — most keep it hidden. **This one ships in the open, in the repo, as hand-editable YAML:**

- [`data/crosswalk.yaml`](data/crosswalk.yaml) — all 79 official LDA general issue codes → sectors, plus ticker → sector rules (explicit per-ticker overrides and a GICS-sector fallback)
- [`data/committee_jurisdictions.yaml`](data/committee_jurisdictions.yaml) — every current House, Senate, and joint committee → jurisdiction sectors

Every mapping row carries a `confidence` grade (`high` / `medium` / `low`), and **every output record names the exact rule that fired** (`mapping_rule_id`, e.g. `ic:HCR->healthcare`, `tk:LMT->defense`, `com:HSAS->defense`). If you disagree with a mapping, you can see it, trace it, and change it — the run summary also lists every issue code, ticker, and committee the crosswalk could *not* resolve, so nothing is silently dropped.

If you build on this data, you know exactly what joined to what and why. That is the point.

### Data sources

| Source | What it provides |
|---|---|
| Senate LDA REST API (`lda.senate.gov`) | Quarterly lobbying filings: registrant, client, issue codes, reported amounts |
| [House](https://apify.com/seralifatih/congress-trading-pipeline-1) / [Senate](https://apify.com/seralifatih/congress-trading-pipeline) trading pipeline actors | Member stock transactions from PTR filings |
| `unitedstates/congress-legislators` | Member roster and committee membership (cached, refreshed monthly) |

All sources are official or community-maintained public records. No scraping of third-party aggregators.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `quarters` | array | last completed quarter | Quarters to cover, e.g. `["2026-Q1"]` |
| `chambers` | array | `["house", "senate"]` | Which chambers to scan |
| `overlap_types` | array | both | Filter to `committee_match` and/or `sector_match_only` |
| `lda_api_key` | secret | — | Optional. The actor ships with a shared key sufficient for typical runs. Provide your own free key from lda.senate.gov for heavy multi-quarter backfills or guaranteed throughput. |
| `max_concurrency` | integer | `5` | Outbound API concurrency |
| `lda_max_pages` | integer | — | Debug cap for cheap test runs |

### Run summary

Every run — including runs that find zero overlaps — writes a `RUN_SUMMARY` to the key-value store: quarters covered, members scanned, overlap counts by type, every unmapped code/ticker/committee/name, and source freshness timestamps. A quarter with no overlaps is itself a fact worth recording.

### How to use

**Apify Console (no code):** open the actor, pick your quarters, run. Results land in the dataset; export as JSON, CSV, or Excel.

**API:**

```bash
curl -X POST "https://api.apify.com/v2/acts/seralifatih~congress-lobbying-trades-overlap/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"quarters": ["2026-Q1"], "chambers": ["house", "senate"]}'
```

**Scheduled:** lobbying data is quarterly by law. A quarterly schedule a few weeks after each LDA filing deadline (Jan 20, Apr 20, Jul 20, Oct 20) keeps a complete archive with four runs a year.

### Pricing

**Predictable per-run pricing.** A small flat start fee plus a fixed charge per quarter processed — you know the exact cost before you run, because you choose the quarters in the input. One quarter or eight, the bill follows your selection, not the number of overlaps found. A run that returns zero overlaps still delivers the run summary and the negative result, which for archival use is an answer, not a failure.

### Tech

- Python 3.11, fully async (`httpx`, bounded concurrency)
- Strict `pydantic` v2 output schema — every record validated before it reaches the dataset
- Retry with exponential backoff and explicit timeouts on every external call
- Committee membership and member roster cached between runs (they change per-Congress, not per-run)

### Limitations

- Federal only. State-level lobbying is out of scope.
- Quarterly granularity — that is the resolution the LDA imposes; nothing here is or can be real-time.
- Sector mapping is inherently judgment-laden. The crosswalk exposes every judgment it makes (`mapping_rule_id`, `confidence`) so you can audit or override them, but no mapping of tickers and issue codes to sectors is beyond argument.
- Trades without a listed ticker (real estate, private funds, bonds) are excluded and counted in the run summary.

### Disclaimer

This actor republishes and cross-references public disclosure records. An overlap record documents that two disclosed activities occurred in the same quarter and sector — it is not evidence of impropriety by any person, and must not be presented as such. Nothing in this actor's output is investment, legal, or any other kind of advice.

# Actor input Schema

## `quarters` (type: `array`):

Calendar quarters to cover, e.g. \["2026-Q1"]. Empty = latest available quarter.

## `chambers` (type: `array`):

Which chambers to scan for trades and committee membership.

## `overlap_types` (type: `array`):

committee\_match = lobbying targeted a committee the member sits on. sector\_match\_only = sector overlap with no committee link.

## `max_concurrency` (type: `integer`):

Bounded concurrency for outbound API calls (respect LDA rate limits). Clamped to 10 server-side regardless of the value entered here, to protect the shared LDA key's rate limit.

## `lda_api_key` (type: `string`):

Optional. The actor ships with a shared key sufficient for typical runs. Provide your own free key from lda.senate.gov for heavy multi-quarter backfills or guaranteed throughput.

## `lda_max_pages` (type: `integer`):

Cap LDA result pages per quarter. Leave empty for full runs; set low (e.g. 5) for cheap test runs.

## `max_filings_per_record` (type: `integer`):

Cap on the lobbying evidence list per overlap record (largest reported amounts kept). The record's lobbying\_filing\_count always shows the uncapped total.

## Actor input object example

```json
{
  "quarters": [],
  "chambers": [
    "house",
    "senate"
  ],
  "overlap_types": [
    "committee_match",
    "sector_match_only"
  ],
  "max_concurrency": 5,
  "max_filings_per_record": 100
}
```

# Actor output Schema

## `overlaps` (type: `string`):

One record per (member, quarter, sector) overlap: member identity, quarter, sector, mapping rule id and confidence, trades\[], lobbying\[], committees\[], overlap\_type (committee\_match / sector\_match\_only), and disclosure\_lag\_days. Each record is traceable to filing IDs and source URLs.

## `runSummary` (type: `string`):

Coverage report for the run: quarters covered, members scanned, overlap counts by type, every unmapped issue code / ticker / committee / member name, and source freshness timestamps. Written on every run, including zero-overlap runs.

# 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 = {
    "quarters": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("seralifatih/congress-lobbying-trades-overlap").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 = { "quarters": [] }

# Run the Actor and wait for it to finish
run = client.actor("seralifatih/congress-lobbying-trades-overlap").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 '{
  "quarters": []
}' |
apify call seralifatih/congress-lobbying-trades-overlap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=seralifatih/congress-lobbying-trades-overlap",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🏛️ Congress Lobbying × Stock Trades Overlap",
        "description": "Cross-references US federal lobbying filings (LDA) with Congressional stock trades (STOCK Act PTRs). One auditable record per member/quarter/sector overlap — trades, lobbying filings, committee links, disclosure lag. Every row traceable to filing IDs. Pairs with our Congress Trade Trackers.",
        "version": "0.0",
        "x-build-id": "fRB54yXmKvmeJIJhU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seralifatih~congress-lobbying-trades-overlap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seralifatih-congress-lobbying-trades-overlap",
                "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/seralifatih~congress-lobbying-trades-overlap/runs": {
            "post": {
                "operationId": "runs-sync-seralifatih-congress-lobbying-trades-overlap",
                "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/seralifatih~congress-lobbying-trades-overlap/run-sync": {
            "post": {
                "operationId": "run-sync-seralifatih-congress-lobbying-trades-overlap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "quarters": {
                        "title": "Quarters",
                        "type": "array",
                        "description": "Calendar quarters to cover, e.g. [\"2026-Q1\"]. Empty = latest available quarter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "chambers": {
                        "title": "Chambers",
                        "type": "array",
                        "description": "Which chambers to scan for trades and committee membership.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "house",
                                "senate"
                            ],
                            "enumTitles": [
                                "House",
                                "Senate"
                            ]
                        },
                        "default": [
                            "house",
                            "senate"
                        ]
                    },
                    "overlap_types": {
                        "title": "Overlap types to include",
                        "type": "array",
                        "description": "committee_match = lobbying targeted a committee the member sits on. sector_match_only = sector overlap with no committee link.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "committee_match",
                                "sector_match_only"
                            ],
                            "enumTitles": [
                                "Committee match",
                                "Sector match only"
                            ]
                        },
                        "default": [
                            "committee_match",
                            "sector_match_only"
                        ]
                    },
                    "max_concurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Bounded concurrency for outbound API calls (respect LDA rate limits). Clamped to 10 server-side regardless of the value entered here, to protect the shared LDA key's rate limit.",
                        "default": 5
                    },
                    "lda_api_key": {
                        "title": "Senate LDA API key",
                        "type": "string",
                        "description": "Optional. The actor ships with a shared key sufficient for typical runs. Provide your own free key from lda.senate.gov for heavy multi-quarter backfills or guaranteed throughput."
                    },
                    "lda_max_pages": {
                        "title": "LDA max pages (debug)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap LDA result pages per quarter. Leave empty for full runs; set low (e.g. 5) for cheap test runs."
                    },
                    "max_filings_per_record": {
                        "title": "Max lobbying filings per record",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on the lobbying evidence list per overlap record (largest reported amounts kept). The record's lobbying_filing_count always shows the uncapped total.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```