# Franchise Investment Data — FDD Costs, Fees & Unit Counts (`jakedata/franchise-investment-data`) Actor

Returns one structured record per US franchise brand: initial investment range, franchise fee, royalty and ad-fund rates, unit counts and 3-year growth, FDD Item 19 revenue, and derived payback, fee-burden and health scores. 171 brands read out of filed Franchise Disclosure Documents. No PII.

- **URL**: https://apify.com/jakedata/franchise-investment-data.md
- **Developed by:** [Jake Mac](https://apify.com/jakedata) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 franchise brand records

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

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

## What's an Apify Actor?

Actors are 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

## Franchise Investment Data — 171 US Brands, Straight From Their FDDs

[![Actor status](https://apify.com/actor-badge?actor=jakedata/franchise-investment-data)](https://apify.com/jakedata/franchise-investment-data)

**What it costs to open, what it costs to run, how big the system is, and what a unit
earns — for 171 US franchise brands, in one comparable schema, read out of the Franchise
Disclosure Documents those franchisors filed with state regulators.**

Every other franchise dataset on the market is a scrape of a listing site: brand name, a
marketing blurb, and an "investment from $X" figure the franchisor chose to advertise. This
one is built from the source document franchisors are legally required to file — so it
carries the numbers the brochure leaves out: the full Item 7 startup range, the royalty and
ad-fund percentages, the three-year outlet table showing whether the system is opening or
closing units, and the Item 19 earnings claim where one exists.

Nothing is fetched at run time. The pack ships inside the Actor, so a run finishes in
seconds, cannot half-fail on a blocked site, and **answers your question on the first call**
— there is no baseline round that returns nothing useful.

### What you get

- **171 brands across 16 categories** — QSR, home services, fitness, automotive, education,
  senior care, pet, personal services, real estate, hospitality and more
- **Cost to open** — franchise fee range and the full FDD Item 7 initial investment range,
  with the line-item breakdown (real estate, equipment, signage, inventory, working capital)
  available on request
- **Cost to run** — royalty rate and basis, ad-fund rate, technology fee, transfer and
  renewal fees, plus every other recurring fee named in Item 6
- **System size and direction** — franchised, company-owned and total units, openings,
  closures, net change, states operating, and the three-year outlet history from Item 20
- **What a unit earns** — Item 19 average and median gross revenue, average net income,
  sample size and reporting period, for the **150 of 171 brands that disclose one**
- **Derived comparables** — payback period, net growth rate, total fee burden, a 0–100
  health score, and a rank within category so a number means something next to its peers
- **Per-record provenance and caveats** — see below. This is the part nobody else ships.

### Why this one

1. **Primary-source data, not a listings scrape.** Item 5, 6, 7, 19 and 20 figures come from
   the filed FDD. **All 171 records have their source filing retained on disk** — the field
   `source_filing_retained` says so per record.
2. **One schema across every brand.** FDDs are 200–900 page PDFs with no common layout.
   Normalising them into comparable fields is the expensive part, and it is done.
3. **The caveats travel with the data.** Every known risk on a record is attached to that
   record as a machine-readable code — not buried in a footnote nobody reads.
4. **Named, honest provenance.** These figures were machine-read from real filings. The
   `provenance` block says exactly that, field group by field group, and names the
   verification suite that keeps it honest.
5. **Agent-ready.** Sparse input works, runs are bounded, output is flat, and the dataset
   schema is declared so an LLM tool call can read the shape without guessing.

### How it works

1. Leave the input empty and run it — you get the 50 strongest systems by health score.
2. Filter to what you are actually shopping for: `maxInvestmentUsd: 250000`,
   `categories: ["Home Services"]`, `requireItem19: true`.
3. Or name the brands you are comparing: `brands: ["dunkin", "Great Clips", "Chick-fil-A"]`.
   A named request is never truncated by the limit.
4. Turn on `includeInvestmentBreakdown` when you need the startup cost line items, and
   `includeUnitHistory` when you need the growth trend.
5. Export to CSV/Excel/JSON, or read the dataset straight from the API.

### Input examples

Everything I can open for under $150k that discloses earnings:

```json
{
  "maxInvestmentUsd": 150000,
  "requireItem19": true,
  "sortBy": "payback_period",
  "limit": 25
}
````

Head-to-head on three brands, with full cost breakdown:

```json
{
  "brands": ["dunkin", "subway", "jersey-mikes"],
  "includeInvestmentBreakdown": true,
  "includeFeeSchedule": true
}
```

Every home-services brand, biggest systems first:

```json
{ "categories": ["Home Services"], "sortBy": "total_units", "limit": 0 }
```

### Output record

One record per brand. Abridged (heavy arrays omitted — they are opt-in):

```json
{
  "brand": "Dunkin'",
  "slug": "dunkin",
  "category": "QSR",
  "subcategory": "coffee-and-donuts",
  "fdd_year": 2025,
  "fdd_filing_state": "MN",
  "source_filing_retained": true,
  "franchise_fee_usd_low": 40000,
  "franchise_fee_usd_high": 90000,
  "initial_investment_usd_low": 532400,
  "initial_investment_usd_high": 1832500,
  "royalty_type": "percentage",
  "royalty_pct": 5.9,
  "royalty_basis": "weekly_gross_sales",
  "ad_fund_pct": 5,
  "total_units": 8499,
  "franchised_units": 8465,
  "company_owned_units": 34,
  "net_unit_change_last_year": 202,
  "has_item19": true,
  "average_gross_revenue_usd": 1304217,
  "item19_sample_size": 7190,
  "payback_period_years": 7.6,
  "fee_burden_pct": 10.9,
  "health_score": 84,
  "category_rank": 6,
  "category_size": 32,
  "risk_flags": [],
  "extraction_confidence": { "initial_investment": 0.93, "unit_data": 0.95 },
  "data_caveats": [],
  "provenance": { "initial_investment": "ai_extracted", "health_score": "derived" },
  "fvs_brand_url": "https://franchisevs.com/franchise/dunkin",
  "status": "brand_record",
  "retrievedAt": "2026-07-19T21:11:27.084Z"
}
```

Ask for a brand that is not in the dataset and you get an explicit `brand_not_found` row
rather than a silently shorter result — so a caller who requested 20 and received 17 can
see which three and why.

#### Data honesty — the caveats are machine-readable

These figures were **machine-read from real filings**. That is not the same as hand-checked,
and it is not the same as invented. The `provenance` block on every record states which:
`ai_extracted` for figures read out of the FDD, `derived` for anything computed from them,
`sourced` for the filing pointer itself, `observed` for the caveats. The block carries its
own legend and names the verification suite — spot-checks against raw PDF text,
render-verification, independent re-extraction, and cross-item regression tests — that makes
publishing machine-read data defensible in the first place.

On top of that, every record carries `data_caveats`, and every code in it is **computed from
the data, not promised in prose**:

| Code | What it means |
|------|---------------|
| `investment_line_items_do_not_reconcile` | The Item 7 line items do not sum to the stated total within 5%. Trust the total; treat the breakdown as indicative. |
| `item19_may_be_a_sub_cohort` | The Item 19 sample is a small fraction of the system. Multi-cohort FDDs publish tenure or format sub-tables next to the system-wide row; verify before quoting it as a system average. |
| `unit_count_is_single_fdd_entity` | Unit counts are the filing entity's franchised outlets, not the brand-wide count in marketing material. Affects several hotel and real-estate brands. |
| `investment_reflects_a_specific_format` | The filing covers a non-standard format (express, in-line, non-traditional) rather than the standalone unit most people picture. |
| `duplicate_slug_family` | The brand appears under more than one slug from different filings. Deduplicate before aggregating. |

18 of 171 brands carry at least one. The other 153 carry an empty array — which is a
statement, not an omission.

`extraction_confidence` adds a second dimension: the extractor's own 0–1 score per block. A
`contract_terms` confidence of 0 means those fields were not reliably recoverable from that
filing, and they are null rather than guessed.

### How much does it cost to pull franchise investment data?

Pay per record returned. Filtered-out brands are free — you are charged for answers, not for
the search.

| What you run | Records | Cost |
|---|---|---|
| Default run (top 50 by health score) | 50 | **$0.25** |
| The whole dataset (`limit: 0`) | 171 | **$0.86** |
| One category, e.g. Home Services | 33 | **$0.17** |
| Head-to-head on 3 brands | 3 | **$0.02** |
| Monthly re-sync of the full set | 171 | **$0.86/month** |

Plus Apify platform usage, which is fractions of a cent here because nothing is fetched — a
full 171-brand run finishes in seconds.

For comparison: a single FDD costs $50–$220 to buy from a commercial provider, and reading
one takes an afternoon. The whole 171-brand set costs less than a dollar.

### Pricing

| Event | Price | When |
|-------|-------|------|
| `brand-record` | **$0.005** ($5 / 1,000) | One per brand record returned |

Records marked `brand_not_found` are not charged.

### How does this compare vs. a franchise-listing scraper?

| | Franchise Investment Data | Listing-site scrapers | State registry scrapers |
|---|---|---|---|
| Source | Filed FDDs | Marketing listings | Registration filings |
| Initial investment range | Full Item 7, low + high | "From $X" headline | ✗ |
| Royalty / ad fund % | ✓ | Rarely | ✗ |
| Unit counts + 3-year trend | ✓ (Item 20) | Current count if lucky | ✗ |
| Franchisee earnings | ✓ (Item 19, 150 brands) | ✗ | ✗ |
| Comparable across brands | ✓ one schema | ✗ per-site shape | ✓ but only names/dates |
| Caveats + confidence per record | ✓ | ✗ | ✗ |
| Breaks when the source site changes | Never — nothing is fetched | Often | Often |

Use a registry scraper to find out **who is registered where**. Use this to find out **what
it costs and what it earns**.

### Other Actors by jakedata

- **[US Liquor Licensing Watch](https://apify.com/jakedata/liquor-licensing-watch)** — what a
  liquor licence costs and requires in all 51 states, plus the city permit overlay, with
  change detection on the state boards.
- **[AI Change Monitor](https://apify.com/jakedata/ai-change-monitor)** — watch any list of
  URLs for meaningful change, with optional AI significance summaries.

### FAQ

**Where does the data come from?**
Franchise Disclosure Documents — the disclosure franchisors must deliver to prospective
franchisees, and file with registration states. They are filed with state regulators and
routinely published by them. The figures here were extracted from those filings; the
compilation, normalisation and derived metrics are ours.

**Is it legal to publish this?**
The underlying FDDs are regulatory filings, and factual data drawn from them — fees, ranges,
unit counts — is not itself copyrightable. What is ours is the compilation: the schema, the
normalisation, the derived metrics and the caveat layer. Nothing here is personal data.

**How current is it?**
167 of 171 records come from 2025 or later filings; every record carries `fdd_year` so you
can judge for yourself rather than trust a "fresh!" badge. FDDs are refreshed annually, so
the dataset is rebuilt as new filings are extracted. Use `updatedSince` to pull only what
has been refiled since your last sync.

**Why only 171 brands?**
Because 171 is the number whose source filing we actually hold. A larger set exists with
estimated figures and no retained document behind them; shipping it here would mean selling
estimates as extracted data. If a brand is absent, it is because we have not extracted its
FDD — not because it does not franchise.

**Is there personal data in it?**
No. Brands, corporate entities, fees and unit counts only. No individuals, no contacts.

**Can I use this for a report or a model?**
Yes. Read the `data_caveats` and `extraction_confidence` fields first, and do not quote an
Item 19 figure carrying `item19_may_be_a_sub_cohort` as a system-wide average without
checking the filing.

**What if I need a brand you do not have?**
Run it with the brand named — you will get a `brand_not_found` row confirming the gap. Tell
us which brands matter and they go to the front of the extraction queue.

***

Built by [jakedata](https://apify.com/jakedata). Openly AI-built and human-supervised: the
extraction is machine-read from primary documents, the verification suite is real, and the
provenance block on every record says which is which.

# Actor input Schema

## `brands` (type: `array`):

Slugs or brand names, e.g. \["dunkin","Great Clips"]. Leave empty to browse the whole dataset with the filters below.

## `categories` (type: `array`):

Restrict to these categories: Automotive, Business Services, Casual Dining, Education, Fitness, Food, Health and Wellness, Home Services, Hospitality, Personal Services, Pet, QSR, Real Estate, Retail, Senior Care, Staffing.

## `maxInvestmentUsd` (type: `integer`):

Keep only brands whose cheapest way in fits this budget. Compared against the low end of FDD Item 7.

## `requireItem19` (type: `boolean`):

Keep only brands with an FDD Item 19 financial performance representation. 150 of 171 have one; the rest disclose nothing about revenue.

## `sortBy` (type: `string`):

Order the results before the limit is applied.

## `limit` (type: `integer`):

Cap the number of brands returned. Set 0 for every match. Ignored when you name brands explicitly — an explicit request is never truncated.

## `minInvestmentUsd` (type: `integer`):

Drop brands whose whole range sits below this. Compared against the high end of FDD Item 7.

## `updatedSince` (type: `string`):

ISO date, e.g. 2025-01-01. Keep only brands whose latest FDD is from that year onward — use it to sync incrementally instead of re-pulling the whole dataset.

## `includeInvestmentBreakdown` (type: `boolean`):

Attach the full startup cost breakdown per brand (real estate, equipment, signage, opening inventory, working capital) plus the FDD's own footnotes.

## `includeFeeSchedule` (type: `boolean`):

Attach every other upfront and recurring fee named in FDD Items 5 and 6 — technology, local advertising, POS, renewal, transfer.

## `includeUnitHistory` (type: `boolean`):

Attach the three-year outlet table from FDD Item 20 so you can see whether the system is opening or closing locations.

## Actor input object example

```json
{
  "brands": [],
  "categories": [],
  "requireItem19": false,
  "sortBy": "health_score",
  "limit": 50,
  "includeInvestmentBreakdown": false,
  "includeFeeSchedule": false,
  "includeUnitHistory": false
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("jakedata/franchise-investment-data").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 = {
    "brands": [],
    "categories": [],
}

# Run the Actor and wait for it to finish
run = client.actor("jakedata/franchise-investment-data").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 '{
  "brands": [],
  "categories": []
}' |
apify call jakedata/franchise-investment-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jakedata/franchise-investment-data",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Franchise Investment Data — FDD Costs, Fees & Unit Counts",
        "description": "Returns one structured record per US franchise brand: initial investment range, franchise fee, royalty and ad-fund rates, unit counts and 3-year growth, FDD Item 19 revenue, and derived payback, fee-burden and health scores. 171 brands read out of filed Franchise Disclosure Documents. No PII.",
        "version": "0.1",
        "x-build-id": "WxQvGdSNVCT0aBdHX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jakedata~franchise-investment-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jakedata-franchise-investment-data",
                "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/jakedata~franchise-investment-data/runs": {
            "post": {
                "operationId": "runs-sync-jakedata-franchise-investment-data",
                "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/jakedata~franchise-investment-data/run-sync": {
            "post": {
                "operationId": "run-sync-jakedata-franchise-investment-data",
                "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": {
                    "brands": {
                        "title": "Brands",
                        "type": "array",
                        "description": "Slugs or brand names, e.g. [\"dunkin\",\"Great Clips\"]. Leave empty to browse the whole dataset with the filters below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Restrict to these categories: Automotive, Business Services, Casual Dining, Education, Fitness, Food, Health and Wellness, Home Services, Hospitality, Personal Services, Pet, QSR, Real Estate, Retail, Senior Care, Staffing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxInvestmentUsd": {
                        "title": "Maximum initial investment (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only brands whose cheapest way in fits this budget. Compared against the low end of FDD Item 7."
                    },
                    "requireItem19": {
                        "title": "Only brands that disclose earnings",
                        "type": "boolean",
                        "description": "Keep only brands with an FDD Item 19 financial performance representation. 150 of 171 have one; the rest disclose nothing about revenue.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "health_score",
                            "investment_low",
                            "investment_high",
                            "total_units",
                            "revenue",
                            "payback_period",
                            "growth",
                            "brand"
                        ],
                        "type": "string",
                        "description": "Order the results before the limit is applied.",
                        "default": "health_score"
                    },
                    "limit": {
                        "title": "Maximum records",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap the number of brands returned. Set 0 for every match. Ignored when you name brands explicitly — an explicit request is never truncated.",
                        "default": 50
                    },
                    "minInvestmentUsd": {
                        "title": "Minimum initial investment (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop brands whose whole range sits below this. Compared against the high end of FDD Item 7."
                    },
                    "updatedSince": {
                        "title": "Filed since",
                        "type": "string",
                        "description": "ISO date, e.g. 2025-01-01. Keep only brands whose latest FDD is from that year onward — use it to sync incrementally instead of re-pulling the whole dataset."
                    },
                    "includeInvestmentBreakdown": {
                        "title": "Include Item 7 line items",
                        "type": "boolean",
                        "description": "Attach the full startup cost breakdown per brand (real estate, equipment, signage, opening inventory, working capital) plus the FDD's own footnotes.",
                        "default": false
                    },
                    "includeFeeSchedule": {
                        "title": "Include the full fee schedule",
                        "type": "boolean",
                        "description": "Attach every other upfront and recurring fee named in FDD Items 5 and 6 — technology, local advertising, POS, renewal, transfer.",
                        "default": false
                    },
                    "includeUnitHistory": {
                        "title": "Include unit history",
                        "type": "boolean",
                        "description": "Attach the three-year outlet table from FDD Item 20 so you can see whether the system is opening or closing locations.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
