# TTB Alcohol Permittee Scraper (`haketa/ttb-alcohol-permittee-scraper`) Actor

Scrape federal alcohol permit records from TTB (Alcohol and Tobacco Tax and Trade Bureau). Download winery, distillery, importer and wholesaler permit lists with owner names, operating names, locations and new permit flags. No browser needed, direct CSV download.

- **URL**: https://apify.com/haketa/ttb-alcohol-permittee-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## TTB Alcohol Permittee Scraper

### What does TTB Alcohol Permittee Scraper do?

TTB Alcohol Permittee Scraper extracts **federal alcohol permit records** from the [TTB (Alcohol and Tobacco Tax and Trade Bureau)](https://www.ttb.gov/), the U.S. federal agency that regulates alcohol production, importation, and wholesale distribution. It downloads bulk CSV permit lists and returns structured data including permit numbers, owner names, operating/trade names, premises addresses, and **new permit flags**.

The scraper covers **wineries, distilleries (DSP), importers, and wholesalers** — every permit type TTB publishes. Data is updated weekly by TTB every Monday.

> ⚠️ **Note**: Brewery (beer producer) data is **not available** — protected under IRC Section 6103 as tax return information. TTB explicitly excludes brewery permits from public lists.

No browser required. No API keys. No login. Direct CSV download with automatic URL discovery.

### Why scrape TTB alcohol permit data?

TTB permit data is the **authoritative federal source** for every legally operating winery, distillery, importer, and wholesaler in the United States. No state-level database offers this nationwide scope. The `New_Permit_Flag` field is particularly valuable — it identifies permits issued in the current week, making it a real-time signal for new market entrants.

Here's why this data is valuable:

- 🍷 **Alcohol distributors & wholesalers** — Find newly opened wineries and distilleries before competitors. A weekly scheduled run with `newPermitsOnly: true` delivers fresh leads every Monday
- 🥃 **Craft spirits & wine importers** — Track which distilleries are getting federal permits in which states. Early relationship-building with new producers is a competitive advantage
- 🏭 **Equipment & packaging suppliers** — New wineries and distilleries need fermentation tanks, bottles, labels, capsules, and corks. This list is a warm lead pipeline for B2B sales
- ⚖️ **Compliance consultants & law firms** — TTB permit application consultants can identify new permit holders as potential clients for ongoing regulatory compliance services
- 💰 **Fintech & insurance** — Companies offering alcohol-industry-specific credit, loans, or insurance products can target new permit holders directly
- 📊 **Market research** — Analyze growth trends in craft spirits and wine production by state, year, and permit type

The Apify platform adds **scheduling, API access, webhook integrations, and proxy rotation** — turning a one-time export into an automated weekly intelligence feed.

### How to scrape TTB alcohol permit data

1. Go to the [TTB Alcohol Permittee Scraper](https://apify.com/haketa/ttb-alcohol-permittee-scraper) on Apify Store
2. Click **Try for free** to open the Actor in Apify Console
3. Select permit categories — `spirits`, `wine`, `wholesalers`, `importers` (or leave empty for all)
4. Optionally enable **New Permits Only** to get only this week's new permit issuances
5. Optionally set a **State Filter** (e.g., `CA`, `NY`, `OR`) to narrow results
6. Set **Max Records** (0 = unlimited) and click **Start**
7. Download your dataset in **JSON, CSV, Excel, or XML** format — or connect it via API

💡 **Pro tip**: Schedule a weekly run every Tuesday with `newPermitsOnly: true` to get a fresh list of newly permitted wineries and distilleries delivered automatically.

### What data can you extract from TTB?

| Field | Description | Example |
|---|---|---|
| Permit Number | Federal permit ID (state + type + sequence) | `CA-W-15651` |
| Owner Name | Legal entity / owner name | `ALASKA PACIFIC BEVERAGE COMPANY LLC` |
| Operating Name | Trade name / DBA (often the brand) | `49th State Brewing` |
| Permit Type | Type code parsed from permit number | `W`, `DSP`, `BWS`, `IMP` |
| Permit Category | Human-readable category | `Winery`, `Distillery` |
| State | US state code (parsed from permit number) | `CA`, `NY`, `OR` |
| Permit Year | Year permit was issued (parsed) | `2021` |
| Street | Premises address | `721 W DEPOT DRIVE STE 49` |
| City | City | `ANCHORAGE` |
| ZIP Code | Premises ZIP | `99501` |
| County | Premises county | `ANCHORAGE` |
| New Permit | Flagged as new this week by TTB | `true` / `false` |

### TTB permit types explained

| Code | Category | Description |
|---|---|---|
| `W` | Winery | Bonded winery, wine cellar, or bottling house |
| `DSP` | Distillery | Distilled Spirits Plant — production, bottling, warehousing |
| `BWS` | Wholesaler | Basic permit wholesaler — interstate commerce |
| `IMP` | Importer | Basic permit importer — bringing alcohol into the US |

#### Permit number format

TTB permit numbers follow the pattern **`{STATE}-{TYPE}-{YEAR}{SEQ}`**:

`CA-W-15651` → California Winery, issued 2015, sequence 651

`AK-DSP-21008` → Alaska Distillery, issued 2021, sequence 008

`NY-IMP-20123` → New York Importer, issued 2020, sequence 123

The Actor automatically parses each permit number to extract `state`, `permitType`, and `permitYear` — no manual parsing needed.

#### About New_Permit_Flag

TTB updates permit lists **every Monday**. The `New_Permit_Flag` field marks permits issued in the most recent update cycle. Use the `newPermitsOnly` input to filter exclusively for new permits — ideal for lead generation and market monitoring.

### Output example

```json
{
  "permitNumber": "AK-W-21009",
  "ownerName": "ALASKA PACIFIC BEVERAGE COMPANY LLC",
  "operatingName": "49th State Brewing",
  "permitType": "W",
  "permitCategory": "Winery",
  "sourceFile": "wine",
  "state": "AK",
  "permitYear": "2021",
  "street": "721 W DEPOT DRIVE STE 49",
  "city": "ANCHORAGE",
  "zipCode": "99501",
  "county": "ANCHORAGE",
  "isNewPermit": false,
  "scrapedAt": "2026-04-23T09:00:00.000Z"
}
````

### How much does it cost to scrape TTB permit data?

TTB Alcohol Permittee Scraper uses a **pay-per-result** pricing model. You only pay for the records you extract:

| Plan | Price per 1,000 records | Example: Wine only | Example: All categories |
|---|---|---|---|
| Free (No discount) | $4.00 | varies | varies |
| Bronze | $3.50 | varies | varies |
| Silver | $3.00 | varies | varies |
| Gold | $2.50 | varies | varies |

The Actor itself runs on **~0.001 CU per run** — the file download and parsing cost is negligible. You can try it for free with a limited number of records on the Apify Free plan.

**Why is TTB data priced higher per record?** Because it includes both legal entity names **and** trade/brand names (Owner\_Name + Operating\_Name), nationwide federal scope, and the unique `New_Permit_Flag` for real-time market intelligence — data points not available from any state-level database.

### Input configuration

Click on the [Input tab](https://apify.com/haketa/ttb-alcohol-permittee-scraper/input-schema) for full details. Key parameters:

| Parameter | Default | Description |
|---|---|---|
| Permit Categories | `["spirits", "wine"]` | Categories to scrape. Leave empty for all |
| New Permits Only | `false` | Only return this week's new permits |
| State Filter | `[]` | Filter by state codes (e.g., CA, NY) |
| Max Records | `200` | Record cap. Set `0` for unlimited |
| Request Delay | `300` ms | Delay between downloads |

### Integrations and API access

You can connect TTB Alcohol Permittee Scraper with almost any cloud service or web app via the Apify platform's built-in [integrations](https://apify.com/integrations). Connect with Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive, and more. You can also access datasets programmatically via the [Apify API](https://docs.apify.com/api).

**Recommended integration**: Set up a weekly Apify Schedule → run with `newPermitsOnly: true` → send results to Google Sheets or Slack via webhook. This creates an automated "new winery/distillery alert" system.

### FAQ

#### Why is brewery data not available?

Brewery permits are classified as **tax return information** under Internal Revenue Code Section 6103 and are explicitly excluded from TTB's public permit lists. This is a federal law restriction, not a technical limitation. All other permit types (winery, distillery, importer, wholesaler) are fully public.

#### How often does TTB update the data?

TTB updates permit list files **every Monday**. The `New_Permit_Flag` field resets each week, marking only permits issued since the last update. For best results, schedule your runs on Tuesday or Wednesday.

#### How does URL discovery work?

TTB's CSV file URLs contain a date component (e.g., `/system/files/2026-04/`) that changes monthly. This Actor **automatically discovers current URLs** by fetching TTB's permittees landing page and extracting download links — no manual URL updates needed.

#### Can I filter by state?

Yes! Use the **State Filter** input to specify one or more US state codes (e.g., `CA`, `NY`, `OR`). The state is parsed from the permit number prefix. Leave empty for nationwide results.

#### What's the difference between Owner\_Name and Operating\_Name?

**Owner\_Name** is the legal entity name (e.g., `ALASKA PACIFIC BEVERAGE COMPANY LLC`). **Operating\_Name** is the trade name or brand (e.g., `49th State Brewing`). They often differ — having both is valuable for matching businesses across databases and for consumer-facing brand identification.

#### Where can I get support?

For issues or feature requests, use the **Issues tab** on the Actor page. I actively monitor feedback and respond promptly. For custom solutions, feel free to reach out.

### Other scrapers

Looking for more license and permit data? Check out:

- 🏛️ [Virginia DPOR License Scraper](https://apify.com/haketa/virginia-dpor-license-scraper) — 45K+ contractor and tradesman license records from Virginia
- 🏗️ [Minnesota DLI License Scraper](https://apify.com/haketa/minnesota-dli-license-scraper) — 200K+ contractor, electrician, plumber, and HVAC bond records from Minnesota

# Actor input Schema

## `permitCategories` (type: `array`):

TTB permit categories to scrape. Each category downloads a separate CSV file. Available: 'spirits' (Distilled Spirits Producers & Bottlers), 'wine' (Wine Producers & Blenders), 'wholesalers' (Basic Permit Wholesalers), 'importers' (Basic Permit Importers). Leave empty to scrape all categories. Note: brewery data is not publicly available.

## `newPermitsOnly` (type: `boolean`):

Only return permits flagged as new this week (New\_Permit\_Flag = 1). Great for tracking newly opened wineries and distilleries.

## `stateFilter` (type: `array`):

Filter by US state codes. Examples: 'CA', 'NY', 'OR', 'TX'. Leave empty for all states.

## `maxRecords` (type: `integer`):

Maximum total records to save across all categories. Set 0 for unlimited.

## `requestDelay` (type: `integer`):

Delay between file downloads in milliseconds.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Usually not needed — TTB serves public files without restrictions.

## Actor input object example

```json
{
  "permitCategories": [
    "spirits",
    "wine"
  ],
  "newPermitsOnly": false,
  "stateFilter": [],
  "maxRecords": 200,
  "requestDelay": 300,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `permitNumber` (type: `string`):

TTB permit number (e.g. CA-W-15651)

## `ownerName` (type: `string`):

Legal entity / owner name

## `operatingName` (type: `string`):

Trade name / DBA (may differ from owner)

## `permitType` (type: `string`):

Permit type code (W, DSP, BWS, IMP etc.)

## `permitCategory` (type: `string`):

Human-readable category (Winery, Distillery etc.)

## `sourceFile` (type: `string`):

TTB source file category

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

US state code parsed from permit number

## `permitYear` (type: `string`):

Year permit was issued (parsed from permit number)

## `street` (type: `string`):

Premises street address

## `city` (type: `string`):

Premises city

## `zipCode` (type: `string`):

Premises ZIP code

## `county` (type: `string`):

Premises county

## `isNewPermit` (type: `string`):

true if flagged as new this week by TTB

## `scrapedAt` (type: `string`):

ISO timestamp when record was scraped

# 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 = {
    "permitCategories": [
        "spirits",
        "wine"
    ],
    "stateFilter": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/ttb-alcohol-permittee-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 = {
    "permitCategories": [
        "spirits",
        "wine",
    ],
    "stateFilter": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/ttb-alcohol-permittee-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 '{
  "permitCategories": [
    "spirits",
    "wine"
  ],
  "stateFilter": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call haketa/ttb-alcohol-permittee-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=haketa/ttb-alcohol-permittee-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TTB Alcohol Permittee Scraper",
        "description": "Scrape federal alcohol permit records from TTB (Alcohol and Tobacco Tax and Trade Bureau). Download winery, distillery, importer and wholesaler permit lists with owner names, operating names, locations and new permit flags. No browser needed, direct CSV download.",
        "version": "0.0",
        "x-build-id": "d5NiCeMQcKZEJa3bQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~ttb-alcohol-permittee-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-ttb-alcohol-permittee-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/haketa~ttb-alcohol-permittee-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-ttb-alcohol-permittee-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/haketa~ttb-alcohol-permittee-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-ttb-alcohol-permittee-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": {
                    "permitCategories": {
                        "title": "Permit Categories",
                        "type": "array",
                        "description": "TTB permit categories to scrape. Each category downloads a separate CSV file. Available: 'spirits' (Distilled Spirits Producers & Bottlers), 'wine' (Wine Producers & Blenders), 'wholesalers' (Basic Permit Wholesalers), 'importers' (Basic Permit Importers). Leave empty to scrape all categories. Note: brewery data is not publicly available.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "newPermitsOnly": {
                        "title": "New Permits Only",
                        "type": "boolean",
                        "description": "Only return permits flagged as new this week (New_Permit_Flag = 1). Great for tracking newly opened wineries and distilleries.",
                        "default": false
                    },
                    "stateFilter": {
                        "title": "State Filter",
                        "type": "array",
                        "description": "Filter by US state codes. Examples: 'CA', 'NY', 'OR', 'TX'. Leave empty for all states.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total records to save across all categories. Set 0 for unlimited.",
                        "default": 200
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between file downloads in milliseconds.",
                        "default": 300
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Usually not needed — TTB serves public files without restrictions."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
