# GovTrack US Congress Scraper (`automation-lab/govtrack-congress-scraper`) Actor

Extract U.S. Congress members, official contact details, bill metadata, and vote records from GovTrack for policy monitoring.

- **URL**: https://apify.com/automation-lab/govtrack-congress-scraper.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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## GovTrack US Congress Scraper

Extract structured U.S. Congress member roles, legislator contact details, bill metadata, and roll-call vote records from the public GovTrack API.

Use this actor when you need repeatable Congress data exports for public-affairs monitoring, government relations, journalism, civic research, compliance research, CRM enrichment, or policy analytics.

### What does GovTrack US Congress Scraper do?

GovTrack US Congress Scraper turns GovTrack's public JSON API into clean Apify datasets.

It can extract:

- 🇺🇸 Current or historical member role records
- 🧑‍⚖️ Senator and representative names
- 🏛️ State, district, party, role type, and term dates
- ☎️ Office phone numbers and office locations
- 🔗 Official websites, contact forms, and GovTrack profile URLs
- 📜 Bill numbers, titles, sponsors, current status, and dates
- 🗳️ Vote questions, results, chamber, session, and totals
- 🧾 Source API URLs and scrape timestamps for auditing

### Who is it for?

This scraper is useful for teams that repeatedly need normalized Congress data.

Common users include:

- 🏢 Government affairs teams tracking legislators and bills
- 📰 Journalists building Congress datasets for reporting
- 🧪 Civic-tech researchers analyzing public legislative data
- ⚖️ Compliance teams monitoring legislation by Congress or chamber
- 📣 Advocacy teams enriching outreach lists with official contact details
- 📊 Data teams feeding BI dashboards or warehouses
- 🤖 AI builders creating RAG datasets about Congress

### Why use this actor?

GovTrack provides useful public API endpoints, but users still need pagination, filtering, export formatting, and repeatable runs.

This actor handles that operational layer on Apify.

Benefits:

- No browser automation required
- No login or API key required
- Pagination handled automatically
- Clean tabular dataset output
- Optional raw JSON for advanced users
- PPE pricing for pay-per-result workflows
- Easy scheduling and integrations through Apify

### Data you can extract

| Field | Description |
| --- | --- |
| `entityType` | `role`, `bill`, or `vote` |
| `recordId` | Stable source identifier or derived key |
| `name` | Member name for role records |
| `title` | Role title, bill title, or vote title |
| `displayNumber` | Bill display number such as `S. 948` |
| `description` | GovTrack description/status text |
| `congress` | Congress number |
| `session` | Vote session/year |
| `chamber` | House or Senate where available |
| `state` | State abbreviation for member roles |
| `district` | House district when applicable |
| `party` | Member party |
| `roleType` | Senator or representative |
| `current` | Whether a role is current |
| `startDate` | Role start date |
| `endDate` | Role end date |
| `introducedDate` | Bill introduction date |
| `status` | Bill status label |
| `statusDate` | Bill status date |
| `sponsorName` | Bill sponsor name |
| `question` | Vote question |
| `result` | Vote result text |
| `passed` | Whether the vote passed |
| `totalPlus` | Yes/plus vote total |
| `totalMinus` | No/minus vote total |
| `totalOther` | Other/present/not voting total |
| `phone` | Congressional office phone |
| `office` | Office address/room |
| `website` | Official website |
| `contactForm` | Contact form URL |
| `govtrackUrl` | GovTrack public URL |
| `sourceApiUrl` | Exact API page used |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape GovTrack Congress data?

This actor uses pay-per-event pricing.

There is a small start event for each run and a per-item event for each saved dataset row.

You control cost with `maxItems`.

Examples:

- A 25-row smoke test is inexpensive.
- A 100-row export validates a realistic workflow.
- A 500+ row run can collect larger bill or vote batches.

Actual billing appears in your Apify run details.

### Input options

#### `mode`

Choose the GovTrack dataset:

- `roles` — member role records, default
- `members` — alias for `roles`
- `bills` — bill metadata
- `votes` — vote metadata

#### `maxItems`

Maximum dataset rows to save.

Use small numbers for first tests and larger numbers for scheduled exports.

#### `current`

For roles mode, set `true` to return current members only.

#### `state`

Filter roles by a two-letter state abbreviation such as `CA`, `TX`, `NY`, or `ME`.

#### `party`

Filter roles by party, for example `Democrat`, `Republican`, or `Independent`.

#### `roleType`

Filter roles to `senator` or `representative`.

#### `congress`

Filter bills or votes by Congress number.

For example:

- `119` is the 2025-2027 Congress
- `118` is the 2023-2025 Congress

#### `session`

Optional vote session/year, such as `2023` or `2024`.

#### `chamber`

Optional vote chamber: `house` or `senate`.

#### `query`

Client-side text match over normalized names, bill titles, vote questions, sponsors, and statuses.

This is useful for narrowing broad API exports without relying on undocumented source search parameters.

#### `includeRaw`

Set to `true` to include the original GovTrack JSON object on every row.

Leave it off for clean spreadsheets.

### Example input: current California members

```json
{
  "mode": "roles",
  "current": true,
  "state": "CA",
  "maxItems": 60
}
````

### Example input: 119th Congress bills

```json
{
  "mode": "bills",
  "congress": 119,
  "maxItems": 100
}
```

### Example input: Senate votes matching a keyword

```json
{
  "mode": "votes",
  "congress": 118,
  "chamber": "senate",
  "query": "nomination",
  "maxItems": 100
}
```

### Example output

```json
{
  "entityType": "role",
  "recordId": "C001035",
  "name": "Sen. Susan Collins [R-ME]",
  "title": "Senator",
  "description": "Senior Senator for Maine",
  "congress": 119,
  "state": "ME",
  "party": "Republican",
  "roleType": "senator",
  "current": true,
  "phone": "202-224-2523",
  "website": "https://www.collins.senate.gov",
  "govtrackUrl": "https://www.govtrack.us/congress/members/susan_collins/300025",
  "sourceApiUrl": "https://www.govtrack.us/api/v2/role?...",
  "scrapedAt": "2026-07-02T00:00:00.000Z"
}
```

### How to use the scraper

1. Open the actor on Apify.
2. Choose a dataset mode.
3. Add filters such as state, role type, Congress, chamber, or query.
4. Set `maxItems`.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, or through the API.
7. Schedule the actor if you need recurring updates.

### Tips for best results

- Start with `roles` mode and `current: true` if you need legislator contacts.
- Use `state` plus `roleType` for small targeted member exports.
- Use `congress` for bills and votes.
- Use `query` for simple policy keyword matching.
- Enable `includeRaw` only when you need fields not yet normalized.
- Keep `maxItems` low while testing.
- Increase `maxItems` for production exports.

### Integrations

You can connect this actor to:

- Google Sheets for public-affairs contact lists
- Airtable for advocacy operations
- BigQuery or Snowflake for policy analytics
- Slack alerts for scheduled monitoring
- CRM systems for legislator outreach context
- RAG pipelines for Congress-focused AI assistants
- Apify webhooks for downstream automation

### 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/govtrack-congress-scraper').call({
  mode: 'roles',
  current: true,
  state: 'CA',
  maxItems: 60,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/govtrack-congress-scraper').call(run_input={
    'mode': 'bills',
    'congress': 119,
    'maxItems': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~govtrack-congress-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"mode":"votes","congress":118,"chamber":"senate","maxItems":100}'
```

### MCP usage

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

MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/govtrack-congress-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/govtrack-congress-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/govtrack-congress-scraper"
    }
  }
}
```

Example prompts:

- "Run the GovTrack Congress scraper for current California members and summarize party distribution."
- "Extract 100 bills from the 119th Congress and list sponsors with current status."
- "Scrape Senate vote records matching nomination and return a CSV-ready table."

### Scheduling workflows

GovTrack data is useful on a recurring schedule.

Suggested schedules:

- Daily bill status export for a tracked Congress
- Weekly current member contact refresh
- Daily vote export during active sessions
- Monthly archive of all current roles by state

### Data freshness

The actor reads live public GovTrack API responses at run time.

Freshness therefore depends on GovTrack's own update cadence.

Each row includes `scrapedAt` so you can audit when your copy was collected.

### Limitations

- The actor does not scrape private or authenticated sources.
- It does not guarantee GovTrack API completeness.
- Some optional fields may be missing for older records.
- `query` is a simple client-side text filter, not semantic search.
- Bill and vote endpoint fields may differ across older Congress sessions.

### Legality

GovTrack exposes public civic information through public pages and JSON API endpoints.

You should still use the data responsibly, respect GovTrack's terms, avoid abusive request volumes, and comply with laws that apply to your use case.

This actor is designed for moderate, paginated API access and transparent source attribution.

### FAQ

#### Can I scrape current members only?

Yes. Use `mode: "roles"` with `current: true`. Add `state`, `party`, or `roleType` to narrow the export.

#### Can I export bills and votes too?

Yes. Use `mode: "bills"` with a `congress` number, or `mode: "votes"` with `congress`, `session`, and `chamber` filters.

### Troubleshooting

#### I received fewer rows than `maxItems`

The source endpoint may have fewer matching records, or your filters/query may be narrow.

Try removing `query`, broadening state/chamber filters, or selecting a different Congress.

#### My role export has empty district values

Senators do not have House districts, so `district` is normally `null` for Senate roles.

#### I need a GovTrack field not shown in the table

Enable `includeRaw` to get the full GovTrack JSON object, then map the field in your downstream workflow.

### Related scrapers

Explore other automation-lab actors for public data and monitoring workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/bulk-url-status-checker
- https://apify.com/automation-lab/google-news-scraper

### Support

If you need another GovTrack endpoint, a new normalized field, or a workflow-specific export shape, open an Apify issue on the actor.

### Changelog

#### 0.1

Initial version with roles/members, bills, and votes modes.

# Actor input Schema

## `mode` (type: `string`):

Select which public GovTrack API endpoint to extract. Roles/members is the safest default and includes legislator contact details.

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

Stop after this many matching rows. Use 100+ for realistic exports and small values for smoke tests.

## `current` (type: `boolean`):

For roles/members mode, return only currently serving legislators when enabled.

## `state` (type: `string`):

Optional two-letter state filter for roles/members, for example CA, TX, NY, or ME.

## `party` (type: `string`):

Optional party filter for roles/members, such as Democrat, Republican, or Independent.

## `roleType` (type: `string`):

Optional roles/members filter for senators or representatives.

## `congress` (type: `integer`):

Filter by Congress number. For example, 119 is the 2025-2027 Congress and 118 is the 2023-2025 Congress.

## `session` (type: `string`):

Optional vote session/year, such as 2023, 2024, or 2025.

## `chamber` (type: `string`):

Optional votes filter for House or Senate votes.

## `query` (type: `string`):

Optional client-side text match against names, titles, questions, sponsors, and statuses.

## `includeRaw` (type: `boolean`):

Attach the original API object to each row for debugging or custom downstream mapping. Leave off for cleaner exports.

## Actor input object example

```json
{
  "mode": "roles",
  "maxItems": 10,
  "current": true,
  "state": "CA",
  "congress": 119,
  "includeRaw": 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 = {
    "mode": "roles",
    "maxItems": 10,
    "current": true,
    "state": "CA",
    "congress": 119,
    "includeRaw": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/govtrack-congress-scraper").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 = {
    "mode": "roles",
    "maxItems": 10,
    "current": True,
    "state": "CA",
    "congress": 119,
    "includeRaw": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/govtrack-congress-scraper").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 '{
  "mode": "roles",
  "maxItems": 10,
  "current": true,
  "state": "CA",
  "congress": 119,
  "includeRaw": false
}' |
apify call automation-lab/govtrack-congress-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GovTrack US Congress Scraper",
        "description": "Extract U.S. Congress members, official contact details, bill metadata, and vote records from GovTrack for policy monitoring.",
        "version": "0.1",
        "x-build-id": "bIMVEmT4VhV2dk7Z9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~govtrack-congress-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-govtrack-congress-scraper",
                "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~govtrack-congress-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-govtrack-congress-scraper",
                "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~govtrack-congress-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-govtrack-congress-scraper",
                "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": {
                    "mode": {
                        "title": "Dataset mode",
                        "enum": [
                            "roles",
                            "members",
                            "bills",
                            "votes"
                        ],
                        "type": "string",
                        "description": "Select which public GovTrack API endpoint to extract. Roles/members is the safest default and includes legislator contact details.",
                        "default": "roles"
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many matching rows. Use 100+ for realistic exports and small values for smoke tests.",
                        "default": 10
                    },
                    "current": {
                        "title": "Current roles only",
                        "type": "boolean",
                        "description": "For roles/members mode, return only currently serving legislators when enabled.",
                        "default": true
                    },
                    "state": {
                        "title": "State abbreviation",
                        "type": "string",
                        "description": "Optional two-letter state filter for roles/members, for example CA, TX, NY, or ME."
                    },
                    "party": {
                        "title": "Party",
                        "type": "string",
                        "description": "Optional party filter for roles/members, such as Democrat, Republican, or Independent."
                    },
                    "roleType": {
                        "title": "Role type",
                        "enum": [
                            "senator",
                            "representative"
                        ],
                        "type": "string",
                        "description": "Optional roles/members filter for senators or representatives."
                    },
                    "congress": {
                        "title": "Congress number",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Filter by Congress number. For example, 119 is the 2025-2027 Congress and 118 is the 2023-2025 Congress.",
                        "default": 119
                    },
                    "session": {
                        "title": "Vote session year",
                        "type": "string",
                        "description": "Optional vote session/year, such as 2023, 2024, or 2025."
                    },
                    "chamber": {
                        "title": "Vote chamber",
                        "enum": [
                            "house",
                            "senate"
                        ],
                        "type": "string",
                        "description": "Optional votes filter for House or Senate votes."
                    },
                    "query": {
                        "title": "Text query",
                        "type": "string",
                        "description": "Optional client-side text match against names, titles, questions, sponsors, and statuses."
                    },
                    "includeRaw": {
                        "title": "Include raw GovTrack JSON",
                        "type": "boolean",
                        "description": "Attach the original API object to each row for debugging or custom downstream mapping. Leave off for cleaner exports.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
