# Florida Sunbiz Business Scraper (`solidcode/sunbiz-scraper`) Actor

\[💰 $7.0 / 1K] Extract Florida business-entity records from the Division of Corporations (Sunbiz): entity name, status, document number, filing dates, registered agent, officers, addresses, and filing history. Search by name, document number, or officer.

- **URL**: https://apify.com/solidcode/sunbiz-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $7.00 / 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.

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

## Florida Sunbiz Business Scraper

Pull Florida business-entity records from the Division of Corporations (Sunbiz) at scale — entity names, statuses, document numbers, FEI/EIN numbers, filing dates, registered agents, full officer rosters, principal and mailing addresses, annual-report history, and downloadable filing PDFs. Built for lead-generation teams, compliance and due-diligence analysts, sales prospectors, and investigative journalists who need clean, structured Florida corporate data without clicking through Sunbiz one record at a time.

### Why This Scraper?

- **Search a person, map their whole Florida portfolio** — feed an officer or registered-agent name and get back every Florida entity that individual is tied to, the single fastest way to surface hidden ownership networks for due diligence.
- **Full officer and director rosters** — every officer, director, and authorized person on each entity, each with their title and address — not just the company name.
- **FEI/EIN tax identifiers** — the federal employer ID for each entity (or "APPLIED FOR" / "NONE" exactly as the state shows it), the join key for matching corporate records against IRS and credit data.
- **Registered-agent contact on every record** — agent name and full address, captured for service-of-process research and conflict checks.
- **Both principal and mailing addresses** — structured into street, city, state, and ZIP, so you can geocode, route mail, or filter by county without re-parsing free text.
- **Annual-report compliance trail** — every year an entity filed its annual report, with the exact filed date, to flag delinquent or recently-reinstated companies.
- **Downloadable filing PDFs** — flip on filing history to capture each amendment, name change, and annual report with a direct document link to the official scanned PDF.
- **Four ways in, one run** — business name, exact document number, officer name, or a pasted Sunbiz URL, all accepted together; no "pick a search mode" step.
- **Every corporate entity type** — profit and non-profit corporations, LLCs, limited partnerships, and registered trademarks all return the same clean, flat record.

### Use Cases

**Lead Generation & Sales Prospecting**
- Build prospect lists of newly-formed Florida companies by filing date
- Pull registered-agent and officer contacts for outreach
- Target entities by type — new LLCs, professional corporations, or non-profits
- Enrich your CRM with verified document numbers and FEI/EIN keys

**Legal & Compliance Research**
- Run conflict checks by mapping every entity an officer is attached to
- Verify a company's active/inactive status before contracting
- Identify the correct registered agent for service of process
- Confirm annual-report compliance and flag delinquent filers

**Due Diligence & Investigations**
- Reconstruct ownership networks from shared officers and agents
- Trace a person's full Florida corporate footprint from one name search
- Pull the filing history behind a name change, merger, or dissolution
- Cross-reference FEI/EIN numbers against external financial datasets

**Market & Investigative Research**
- Track corporate formation trends across entity types
- Monitor a competitor's filings, amendments, and status changes
- Source public-record evidence for journalism and watchdog reporting
- Power analytics dashboards with structured Florida registry data

### Getting Started

#### Search by Business Name

The simplest start — one or more company names. Partial matches are supported:

```json
{
    "searchTerms": ["Disney"],
    "maxResults": 50
}
````

#### Look Up Exact Document Numbers

Already have document numbers? Each resolves straight to a full entity record:

```json
{
    "documentNumbers": ["P21000012345", "L98000054321"],
    "includeFilingHistory": true
}
```

#### Find Every Company Tied to a Person

```json
{
    "officerNames": ["Smith John"],
    "maxResults": 200
}
```

#### Full-Featured Example

Mix every input type in a single run and capture filing history:

```json
{
    "searchTerms": ["Sunshine Holdings"],
    "documentNumbers": ["P21000012345"],
    "officerNames": ["Garcia Maria"],
    "startUrls": [
        "https://search.sunbiz.org/Inquiry/CorporationSearch/SearchResultDetail?inquirytype=EntityName&directionType=Initial&searchNameOrder=DISNEY"
    ],
    "includeFilingHistory": true,
    "maxResults": 1000
}
```

### Input Reference

#### What to Scrape

Provide at least one input. Business names, document numbers, officer names, and Sunbiz URLs can all be combined in one run.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["Disney"]` | Business or entity names to search (e.g. "Disney", "Sunshine Holdings LLC"). Partial matches supported — each term runs its own search and returns every matching entity. |
| `documentNumbers` | string\[] | `[]` | Exact Florida document numbers to look up (e.g. "L21000012345", "P98000054321"). Each resolves straight to a single entity record. |
| `officerNames` | string\[] | `[]` | Officer or registered-agent names to search (e.g. "Smith John"). Returns every Florida entity that person is listed on. |
| `startUrls` | string\[] | `[]` | Paste Sunbiz URLs (search.sunbiz.org). Accepts both search-result pages and individual entity detail pages — the actor detects which is which automatically. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeFilingHistory` | boolean | `false` | Add each entity's filing / document-event history (amendments, annual reports, name changes) to its record, with a downloadable link to each official PDF. Off by default to keep records compact. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of entity records across all inputs. Set to `0` for no cap (an upper limit of 50,000 still applies). Results arrive in pages of about 20; the final page is kept whole. |

### Output

Each result is one flat entity record. Here's a representative example with filing history enabled:

```json
{
    "documentNumber": "P21000012345",
    "entityName": "SUNSHINE HOLDINGS, INC.",
    "entityType": "Florida Profit Corporation",
    "status": "Active",
    "feiEinNumber": "87-1234567",
    "filingDate": "02/14/2021",
    "effectiveDate": "02/14/2021",
    "state": "FL",
    "lastEvent": "ANNUAL REPORT",
    "lastEventDate": "03/01/2026",
    "principalAddress": {
        "street": "100 Biscayne Blvd, Suite 400",
        "city": "Miami",
        "state": "FL",
        "zip": "33132"
    },
    "mailingAddress": {
        "street": "PO Box 1234",
        "city": "Miami",
        "state": "FL",
        "zip": "33101"
    },
    "registeredAgent": {
        "name": "Garcia, Maria",
        "address": "100 Biscayne Blvd, Suite 400, Miami, FL 33132"
    },
    "officers": [
        { "title": "President", "name": "Smith, John", "address": "100 Biscayne Blvd, Miami, FL 33132" },
        { "title": "Director", "name": "Lee, Anna", "address": "200 Ocean Dr, Miami, FL 33139" }
    ],
    "annualReports": [
        { "year": "2026", "filedDate": "03/01/2026" },
        { "year": "2025", "filedDate": "02/20/2025" }
    ],
    "filingHistory": [
        {
            "description": "ANNUAL REPORT",
            "date": "03/01/2026",
            "documentLink": "https://search.sunbiz.org/Inquiry/CorporationSearch/ConvertTiffToPDF?..."
        }
    ],
    "url": "https://search.sunbiz.org/Inquiry/CorporationSearch/SearchResultDetail?...",
    "searchType": "name",
    "searchInput": "Sunshine Holdings"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `documentNumber` | string | Florida state document identifier |
| `entityName` | string | Official registered business name |
| `entityType` | string | Entity type (e.g. Florida Profit Corporation, Florida Limited Liability Company, Foreign Profit Corporation, Trademark) |
| `status` | string | Entity status (Active / Inactive) |
| `feiEinNumber` | string | FEI/EIN federal tax ID, or "NONE" / "APPLIED FOR" as shown |
| `filingDate` | string | Date the entity was filed with the state |
| `effectiveDate` | string | Effective date, when present |
| `state` | string | State of formation (FL for domestic) |
| `lastEvent` | string | Most recent recorded event (e.g. ANNUAL REPORT, AMENDMENT) |
| `lastEventDate` | string | Date of the most recent event |
| `url` | string | Sunbiz detail-page URL for the entity |

#### Addresses

| Field | Type | Description |
|-------|------|-------------|
| `principalAddress` | object | Principal place of business — `street`, `city`, `state`, `zip` |
| `mailingAddress` | object | Mailing address — `street`, `city`, `state`, `zip` |

#### People & Registered Agent

| Field | Type | Description |
|-------|------|-------------|
| `registeredAgent` | object | Registered agent — `name` and full `address` |
| `officers` | object\[] | Officers and directors, each with `title`, `name`, `address` |
| `authorizedPersons` | object\[] | Authorized persons (mainly LLCs), each with `title`, `name`, `address` |

#### Compliance & Filings

| Field | Type | Description |
|-------|------|-------------|
| `annualReports` | object\[] | Annual reports on file, each with `year` and `filedDate` |
| `filingHistory` | object\[] | Filing / document-event history when enabled, each with `description`, `date`, and a downloadable `documentLink` PDF |
| `searchType` | string | Which input produced this row (name / document / officer / url) |
| `searchInput` | string | The exact term, number, or URL that produced this row |

### Tips for Best Results

- **Document-number lookup is the fastest path** — if you already know the document number, use `documentNumbers`; each one resolves straight to a full record with no search step.
- **Officer-name search maps a person's whole portfolio** — `officerNames` returns every Florida entity an individual is attached to, ideal for ownership research and conflict checks where a name beats a company list.
- **Cast a wider net with partial names** — Sunbiz matches from the start of a business name, so "Sunshine" pulls every entity beginning with it; shorten the term to broaden, lengthen it to narrow.
- **Leave filing history off unless you need PDFs** — `includeFilingHistory` makes each record larger; turn it on only when you want the amendment trail and downloadable document links.
- **Start small, then scale** — set `maxResults` to 25–50 on your first run to confirm the data fits your needs, then raise it for the full pull.
- **Combine inputs in one run** — mix business names, document numbers, officer names, and pasted URLs together; the `searchType` field tells you which input produced each row.
- **Use FEI/EIN as your join key** — `feiEinNumber` is the cleanest identifier for matching Sunbiz records against external financial, tax, or credit datasets.

### Pricing

**$7.00 per 1,000 results** — flat pay-per-result, undercutting the comparable Florida registry actor by 30%. No compute charges — you only pay per result returned.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.70 |
| 1,000 | $7.00 |
| 10,000 | $70.00 |
| 100,000 | $700.00 |

A "result" is any entity record in the output dataset. Platform fees (storage, data transfer) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

Florida business-entity records published by the Division of Corporations (Sunbiz) are public records under Florida law. This actor is designed for legitimate research, compliance, due-diligence, and lead-generation use. You are responsible for complying with applicable laws, Sunbiz's terms of use, and any rules governing the handling of personal data. Do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `searchTerms` (type: `array`):

Business or entity names to search (e.g. 'Disney', 'Sunshine Holdings LLC'). Partial matches are supported — each term runs its own search and returns every matching entity.

## `documentNumbers` (type: `array`):

Exact Florida document numbers to look up (e.g. 'L21000012345', 'P98000054321'). Each resolves straight to a single entity record.

## `officerNames` (type: `array`):

Officer or registered-agent names to search (e.g. 'Smith John'). Returns every Florida entity that person is listed on — useful for due diligence and ownership research.

## `startUrls` (type: `array`):

Paste one or more Sunbiz URLs (search.sunbiz.org). Accepts both search-result pages and individual entity detail pages — the actor detects which is which automatically.

## `includeFilingHistory` (type: `boolean`):

Add each entity's filing / document-event history (amendments, annual reports, name changes, etc.) to its result row. Off by default — this data is already on the entity page, so enabling it does not slow runs, but it makes each record larger.

## `maxResults` (type: `integer`):

Hard cap on the total number of entity records across all inputs. Default 100 — increase for larger runs, or set to 0 for no cap (an internal upper limit of 50,000 still applies). The actor stops requesting new result pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

```json
{
  "searchTerms": [
    "Disney"
  ],
  "documentNumbers": [],
  "officerNames": [],
  "startUrls": [],
  "includeFilingHistory": false,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped business entities with key fields.

# 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 = {
    "searchTerms": [
        "Disney"
    ],
    "documentNumbers": [],
    "officerNames": [],
    "startUrls": [],
    "includeFilingHistory": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/sunbiz-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 = {
    "searchTerms": ["Disney"],
    "documentNumbers": [],
    "officerNames": [],
    "startUrls": [],
    "includeFilingHistory": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/sunbiz-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 '{
  "searchTerms": [
    "Disney"
  ],
  "documentNumbers": [],
  "officerNames": [],
  "startUrls": [],
  "includeFilingHistory": false,
  "maxResults": 100
}' |
apify call solidcode/sunbiz-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Florida Sunbiz Business Scraper",
        "description": "[💰 $7.0 / 1K] Extract Florida business-entity records from the Division of Corporations (Sunbiz): entity name, status, document number, filing dates, registered agent, officers, addresses, and filing history. Search by name, document number, or officer.",
        "version": "1.0",
        "x-build-id": "e9OgjKJWbOz9TxbnV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~sunbiz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-sunbiz-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/solidcode~sunbiz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-sunbiz-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/solidcode~sunbiz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-sunbiz-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": {
                    "searchTerms": {
                        "title": "Business Names",
                        "type": "array",
                        "description": "Business or entity names to search (e.g. 'Disney', 'Sunshine Holdings LLC'). Partial matches are supported — each term runs its own search and returns every matching entity.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "documentNumbers": {
                        "title": "Document Numbers",
                        "type": "array",
                        "description": "Exact Florida document numbers to look up (e.g. 'L21000012345', 'P98000054321'). Each resolves straight to a single entity record.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "officerNames": {
                        "title": "Officer / Registered Agent Names",
                        "type": "array",
                        "description": "Officer or registered-agent names to search (e.g. 'Smith John'). Returns every Florida entity that person is listed on — useful for due diligence and ownership research.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Sunbiz URLs",
                        "type": "array",
                        "description": "Paste one or more Sunbiz URLs (search.sunbiz.org). Accepts both search-result pages and individual entity detail pages — the actor detects which is which automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeFilingHistory": {
                        "title": "Include Filing History",
                        "type": "boolean",
                        "description": "Add each entity's filing / document-event history (amendments, annual reports, name changes, etc.) to its result row. Off by default — this data is already on the entity page, so enabling it does not slow runs, but it makes each record larger.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of entity records across all inputs. Default 100 — increase for larger runs, or set to 0 for no cap (an internal upper limit of 50,000 still applies). The actor stops requesting new result pages once this number is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
