# FEC Electronic Filing Parser (`automation-lab/fec-electronic-filing-parser`) Actor

Parse public FEC electronic filing CSVs into filing summaries and schedule-level JSON rows for campaign-finance research.

- **URL**: https://apify.com/automation-lab/fec-electronic-filing-parser.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## FEC Electronic Filing Parser

Turn public FEC electronic filing CSVs into clean JSON rows for campaign-finance research, compliance monitoring, journalism, and political-data pipelines.

The actor uses the official OpenFEC filings API to find filing metadata, downloads each filing's public `csv_url`, parses the raw electronic filing rows, and emits filing summaries plus schedule-level records in an Apify dataset.

### What does FEC Electronic Filing Parser do?

FEC Electronic Filing Parser converts Federal Election Commission electronic filing assets into structured dataset items.

It can:

- 🔎 Find filings from OpenFEC by committee, form type, report year, and receipt-date range.
- 🎯 Parse exact filings when you already know the FEC filing ID.
- 📄 Download the official FEC CSV filing asset linked by OpenFEC.
- 🧾 Emit one filing summary item per filing.
- 📊 Emit one parsed schedule-row item per raw CSV row.
- 🧱 Preserve every raw column as stable `col001`, `col002`, and so on.
- 🏷️ Add friendly labels for common row types such as `HDR`, `F3`, `F3X`, `F24`, `SA11AI`, and `SB17`.

### Who is it for?

This actor is useful for teams that repeatedly inspect campaign-finance filing data.

- 📰 Investigative journalists tracking new committee filings.
- 🗳️ Political data teams building campaign-finance databases.
- ⚖️ Compliance analysts checking committee reports.
- 🧑‍💻 Civic-tech developers who need FEC CSV rows as API-ready JSON.
- 📈 Researchers comparing filings over time.
- 🏛️ Public-affairs teams monitoring PAC and campaign activity.

### Why use this actor?

FEC filing pages are not always convenient for automation. Some document-rendering HTML pages may block automated requests, but OpenFEC metadata and CSV filing assets are public and machine-readable.

This actor focuses on the reliable path:

- OpenFEC API for search and metadata.
- FEC CSV assets for source rows.
- Apify datasets for export, scheduling, integrations, and API access.

### Data source

The actor uses public Federal Election Commission data.

Primary source:

- OpenFEC filings API: `https://api.open.fec.gov/v1/filings/`
- CSV filing assets exposed in each filing's `csv_url`

The actor does not require a browser, cookies, login, or private credentials.

### What data can you extract?

Each output item includes filing context such as:

| Field | Description |
| --- | --- |
| `itemType` | `filing_summary` or `schedule_row` |
| `fecFileId` | OpenFEC file id such as `FEC-870444` |
| `numericFilingId` | Numeric filing id such as `870444` |
| `committeeId` | FEC committee id |
| `committeeName` | Committee name from OpenFEC |
| `formType` | Form type such as `F3` or `F3X` |
| `reportYear` | Filing report year |
| `documentDescription` | OpenFEC filing description |
| `rowType` | CSV row type such as `SA11AI` or `SB17` |
| `columns` | Flattened object containing all parsed row columns |
| `normalized` | Selected friendly fields when row labels are known |
| `csvUrl` | Official FEC CSV file URL |
| `pdfUrl` | Official PDF URL when OpenFEC provides one |

### How much does it cost to parse FEC filings?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- Each filing summary or parsed schedule row is charged as one item.

The first-run defaults are intentionally small: one known filing, up to three filings, and up to 100 dataset items. Increase `maxItems` and provide your own OpenFEC API key for production workloads.

### Input options

#### Filing IDs

Use `filingIds` when you already know exact filing identifiers.

Example:

```json
{
  "filingIds": ["870444"],
  "maxItems": 100
}
````

#### Committee search

Use `committeeIds`, `formTypes`, and `reportYear` to discover filings from OpenFEC.

```json
{
  "committeeIds": ["C00465880"],
  "formTypes": ["F3"],
  "reportYear": 2013,
  "maxFilings": 3,
  "maxItems": 100
}
```

#### Date filters

Use `minDate` and `maxDate` with `YYYY-MM-DD` values when you only want filings from a specific receipt-date window.

### Output format

The actor writes all results to the default Apify dataset.

Two item types are emitted:

1. `filing_summary` — one metadata record per filing.
2. `schedule_row` — one parsed row from the filing CSV.

This lets you export a single CSV or JSON dataset while still filtering by `itemType` downstream.

### Example output

```json
{
  "itemType": "schedule_row",
  "fecFileId": "FEC-870444",
  "committeeId": "C00465880",
  "committeeName": "FRIENDS OF SCOTT ROBINSON",
  "formType": "F3",
  "reportYear": 2013,
  "rowType": "SB17",
  "rowNumber": 4,
  "rowColumnCount": 25,
  "columns": {
    "row_type": "SB17",
    "committee_id": "C00465880",
    "payee_name": "NGP SOFTWARE"
  },
  "source": "fec-csv"
}
```

### How to parse one FEC filing

1. Open the actor on Apify.
2. Paste one or more FEC filing IDs into `filingIds`.
3. Keep `maxItems` low for the first run.
4. Start the actor.
5. Export the dataset as JSON, CSV, Excel, or via API.

### How to monitor a committee

1. Add one or more committee IDs.
2. Add the form types you care about, for example `F3`, `F3X`, or `F24`.
3. Set a report year or date range.
4. Schedule the actor daily, weekly, or monthly.
5. Send new dataset rows to your warehouse, spreadsheet, or alerting tool.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fec-electronic-filing-parser').call({
  filingIds: ['870444'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/fec-electronic-filing-parser').call(run_input={
    'filingIds': ['870444'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~fec-electronic-filing-parser/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"filingIds":["870444"],"maxItems":100}'
```

### MCP integration

Use the Apify MCP server to call this actor from Claude Desktop, Claude Code, or other MCP-compatible tools.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/fec-electronic-filing-parser
```

Claude Code setup:

```bash
claude mcp add apify-fec-parser --transport http https://mcp.apify.com/?tools=automation-lab/fec-electronic-filing-parser
```

Claude Desktop setup: open **Settings → Developer → Edit Config**, add the JSON below, save it, and restart Claude Desktop so the Apify MCP server is available.

Cursor setup: open **Settings → MCP → Add new global MCP server**, use transport **HTTP**, and paste the MCP URL above.

VS Code setup: install an MCP-compatible extension, add a new HTTP MCP server, and use the MCP URL above for the server endpoint.

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-fec-parser": {
      "url": "https://mcp.apify.com/?tools=automation-lab/fec-electronic-filing-parser"
    }
  }
}
```

Example prompts:

- "Parse FEC filing 870444 and summarize the schedule row types."
- "Fetch recent F3 filings for committee C00465880 and export the parsed rows."
- "Compare raw row counts across the latest filings for this committee."

### Tips for reliable runs

- Provide your own OpenFEC API key for larger runs.
- Use exact filing IDs when reproducibility matters.
- Keep `maxItems` high enough for filings with many schedule rows.
- Enable `includeRawRows` only when you need exact source arrays.
- Treat `columns` as the full source-preserving representation.
- Treat `normalized` as a convenience layer that may expand over time.

### Limitations

FEC electronic filing CSV layouts vary by form and schedule. This actor preserves every source column even when a row type is not yet fully labeled.

The actor does not scrape blocked HTML rendering pages. It uses OpenFEC metadata and official CSV assets instead.

The default `DEMO_KEY` is suitable for small smoke tests, not heavy production use.

### Legality

FEC filings are public government records. You are responsible for using exported data in compliance with applicable laws, FEC rules, Apify terms, and your organization's policies.

Do not use the actor to misrepresent official filings. Keep links to the original FEC CSV, PDF, or filing page when publishing analysis.

### Integrations

Common workflows include:

- Send parsed rows to Google Sheets for analyst review.
- Load schedule rows into BigQuery, Snowflake, or PostgreSQL.
- Trigger Slack alerts when a committee files a new report.
- Join parsed FEC rows with committee, candidate, or election-cycle reference tables.
- Archive raw filing rows for audit evidence.

### Related Apify actors

You may also need other Automation Lab actors for adjacent workflows:

- SEC filing and company-data actors for public-market research.
- Government contract and tender scrapers for public-sector intelligence.
- Website contact and lead enrichment actors for outreach workflows.

### FAQ

#### Why did my run return no filings?

Check that the committee ID, form type, report year, and date filters exist in OpenFEC. Try one exact `filingIds` value first to verify the parser path.

#### Why did OpenFEC return a rate-limit error?

The actor defaults to OpenFEC `DEMO_KEY`. For repeated or large runs, create a free OpenFEC API key and add it to the `apiKey` input.

#### Why are some row fields named `col001`?

FEC row layouts vary. The actor keeps all values under stable column keys and labels common row types where safe.

### Changelog

Initial version:

- OpenFEC filings search.
- Exact filing ID parsing.
- CSV row parser.
- Filing summaries and schedule-row dataset items.
- Optional raw row arrays.

### Support

If you need a specific FEC schedule normalized into named fields, open an issue with sample filing IDs and the row types you want mapped.

### Summary

FEC Electronic Filing Parser gives analysts a repeatable way to convert public FEC electronic filings into structured Apify datasets without browser automation or fragile HTML scraping.

# Actor input Schema

## `filingIds` (type: `array`):

Optional exact filing IDs to parse. Use values like FEC-870444 or 870444. If omitted, the actor searches filings with the filters below.

## `committeeIds` (type: `array`):

Optional FEC committee IDs to search, such as C00465880. Used when filingIds is empty or when you want additional filings.

## `formTypes` (type: `array`):

Optional FEC form types to search, such as F3, F3X, F24, F5, or F99.

## `reportYear` (type: `integer`):

Optional report year filter for OpenFEC filing search.

## `minDate` (type: `string`):

Optional lower bound for OpenFEC receipt date search, formatted YYYY-MM-DD.

## `maxDate` (type: `string`):

Optional upper bound for OpenFEC receipt date search, formatted YYYY-MM-DD.

## `maxFilings` (type: `integer`):

Maximum number of filing CSV files to download and parse.

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

Maximum filing summaries and parsed CSV rows to emit across all filings.

## `includeFilingSummaries` (type: `boolean`):

Emit one metadata summary item per filing before parsed schedule rows.

## `includeRawRows` (type: `boolean`):

Include the original CSV field array on each schedule row. Disable for smaller exports.

## `apiKey` (type: `string`):

Optional OpenFEC API key. Leave blank to use DEMO\_KEY for small runs; provide your own key for larger production runs.

## Actor input object example

```json
{
  "filingIds": [
    "870444"
  ],
  "committeeIds": [
    "C00465880"
  ],
  "formTypes": [
    "F3"
  ],
  "reportYear": 2013,
  "maxFilings": 3,
  "maxItems": 20,
  "includeFilingSummaries": true,
  "includeRawRows": false
}
```

# Actor output Schema

## `overview` (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 = {
    "filingIds": [
        "870444"
    ],
    "committeeIds": [
        "C00465880"
    ],
    "formTypes": [
        "F3"
    ],
    "reportYear": 2013,
    "maxFilings": 3,
    "maxItems": 20,
    "includeFilingSummaries": true,
    "includeRawRows": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fec-electronic-filing-parser").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 = {
    "filingIds": ["870444"],
    "committeeIds": ["C00465880"],
    "formTypes": ["F3"],
    "reportYear": 2013,
    "maxFilings": 3,
    "maxItems": 20,
    "includeFilingSummaries": True,
    "includeRawRows": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fec-electronic-filing-parser").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 '{
  "filingIds": [
    "870444"
  ],
  "committeeIds": [
    "C00465880"
  ],
  "formTypes": [
    "F3"
  ],
  "reportYear": 2013,
  "maxFilings": 3,
  "maxItems": 20,
  "includeFilingSummaries": true,
  "includeRawRows": false
}' |
apify call automation-lab/fec-electronic-filing-parser --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/fec-electronic-filing-parser",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FEC Electronic Filing Parser",
        "description": "Parse public FEC electronic filing CSVs into filing summaries and schedule-level JSON rows for campaign-finance research.",
        "version": "0.1",
        "x-build-id": "sAvGkQQUXZ8aMFKxg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fec-electronic-filing-parser/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fec-electronic-filing-parser",
                "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/automation-lab~fec-electronic-filing-parser/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fec-electronic-filing-parser",
                "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/automation-lab~fec-electronic-filing-parser/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fec-electronic-filing-parser",
                "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": {
                    "filingIds": {
                        "title": "FEC filing IDs",
                        "type": "array",
                        "description": "Optional exact filing IDs to parse. Use values like FEC-870444 or 870444. If omitted, the actor searches filings with the filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "committeeIds": {
                        "title": "Committee IDs",
                        "type": "array",
                        "description": "Optional FEC committee IDs to search, such as C00465880. Used when filingIds is empty or when you want additional filings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "formTypes": {
                        "title": "Form types",
                        "type": "array",
                        "description": "Optional FEC form types to search, such as F3, F3X, F24, F5, or F99.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reportYear": {
                        "title": "Report year",
                        "minimum": 1975,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Optional report year filter for OpenFEC filing search."
                    },
                    "minDate": {
                        "title": "Minimum receipt date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional lower bound for OpenFEC receipt date search, formatted YYYY-MM-DD."
                    },
                    "maxDate": {
                        "title": "Maximum receipt date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional upper bound for OpenFEC receipt date search, formatted YYYY-MM-DD."
                    },
                    "maxFilings": {
                        "title": "Maximum filings",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of filing CSV files to download and parse.",
                        "default": 3
                    },
                    "maxItems": {
                        "title": "Maximum dataset items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum filing summaries and parsed CSV rows to emit across all filings.",
                        "default": 20
                    },
                    "includeFilingSummaries": {
                        "title": "Include filing summary rows",
                        "type": "boolean",
                        "description": "Emit one metadata summary item per filing before parsed schedule rows.",
                        "default": true
                    },
                    "includeRawRows": {
                        "title": "Include raw CSV arrays",
                        "type": "boolean",
                        "description": "Include the original CSV field array on each schedule row. Disable for smaller exports.",
                        "default": false
                    },
                    "apiKey": {
                        "title": "OpenFEC API key",
                        "type": "string",
                        "description": "Optional OpenFEC API key. Leave blank to use DEMO_KEY for small runs; provide your own key for larger production runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```