# SEC XBRL Company Facts Scraper (`parseforge/sec-xbrl-company-facts-scraper`) Actor

Pull structured financial facts from SEC EDGAR by ticker or CIK number. Each row carries the company name, GAAP concept, reported value, unit, fiscal year and period, form type, and filing date. Useful for building fundamentals histories, equity research, and audit checks.

- **URL**: https://apify.com/parseforge/sec-xbrl-company-facts-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📊 SEC XBRL Company Facts Scraper

> 🚀 **Pull structured financial facts straight from SEC EDGAR in seconds.** One run on Apple returned 1,562 fact observations across 8 core concepts, each tagged with fiscal year, period, form, and filing date.

> 🕒 **Last updated:** 2026-06-04 · **📊 16 fields** per record · keyless SEC source · 10,000+ U.S. public companies covered

The SEC XBRL Company Facts Scraper reads the official structured financial data the U.S. Securities and Exchange Commission publishes for every public company that files in XBRL. Give it a list of tickers or CIK numbers, pick the financial concepts you care about, and it returns one clean row per reported fact observation. Each row carries the company name, the us-gaap concept, the reported value and unit, the fiscal year and period, the form type (10-K or 10-Q), and the exact date the figure was filed.

Coverage spans every company with XBRL filings in SEC EDGAR, more than 10,000 active tickers mapped to their CIK. Tickers are resolved to CIK automatically using the SEC company ticker map, so you can mix symbols like AAPL and MSFT with raw CIK numbers in the same run. Results are sorted newest first by filing date.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Financial analysts and equity researchers | Building company financial time series |
| Fintech and data engineering teams | Feeding fundamentals into models and dashboards |
| Accountants and auditors | Cross-checking reported figures by filing |
| Investors and quants | Backtesting on revenue, net income, and EPS |

### 📋 What the SEC XBRL Company Facts Scraper does

This Actor calls the SEC EDGAR XBRL company facts endpoint for each company you request, then flattens the nested taxonomy into a tidy row per observation. It handles the mandatory SEC contact User-Agent header on every request, resolves tickers to CIK, filters by concept and form, and emits records ordered by filing date with the most recent figures first.

- Accepts tickers (AAPL) or CIK numbers (320193 or 0000320193).
- Pulls all reported us-gaap fact observations for each company.
- Filters to a default set of key metrics or any concepts you name.
- Returns value, unit, fiscal year, fiscal period, form, and filing date per fact.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `companies` | array | yes | Tickers or CIK numbers to pull facts for. Prefilled with AAPL. |
| `concepts` | array | no | us-gaap concept names. Defaults to a key set of 8 metrics. |
| `forms` | array | no | Filter by form type, for example 10-K or 10-Q. Empty means all. |
| `maxItems` | integer | no | Free users limited to 10 items. Paid users up to 1,000,000. |

Example input pulling Apple with the default concept set:

```json
{
    "companies": ["AAPL"],
    "maxItems": 50
}
````

Example input pulling two companies, only annual reports, for revenue and net income:

```json
{
    "companies": ["MSFT", "320193"],
    "concepts": ["Revenues", "NetIncomeLoss"],
    "forms": ["10-K"],
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** SEC EDGAR requires a descriptive User-Agent with contact info on every request. This Actor sends one automatically, so you never get blocked for a missing header. The `frame` field is present only on observations the SEC has assigned a reporting frame, so it is populated on some rows and empty on others by design.

### 📊 Output

| Field | Description |
|---|---|
| 🆔 cik | 10-digit zero-padded SEC CIK, prefixed CIK |
| 🏢 entityName | Registered company name |
| 📚 taxonomy | Reporting taxonomy (us-gaap) |
| 📐 concept | XBRL concept name |
| 🏷 label | Human readable concept label |
| 📏 unit | Reporting unit (USD, USD/shares) |
| 💲 value | Reported numeric value |
| 📅 fiscalYear | Fiscal year of the observation |
| 🗓 fiscalPeriod | Fiscal period (FY, Q1, Q2, Q3) |
| 📄 form | SEC form type (10-K, 10-Q) |
| 🗂 filed | Date the figure was filed |
| ⏱ periodStart | Start of the reporting period (duration facts) |
| ⏳ periodEnd | End of the reporting period |
| 🖼 frame | SEC reporting frame when assigned |
| 🔖 accession | Filing accession number |
| 🕒 scrapedAt | Timestamp the record was collected |

Three real sample records from a live run on AAPL:

```json
{
    "cik": "CIK0000320193",
    "entityName": "Apple Inc.",
    "taxonomy": "us-gaap",
    "concept": "Assets",
    "label": "Assets",
    "unit": "USD",
    "value": 371082000000,
    "fiscalYear": 2026,
    "fiscalPeriod": "Q2",
    "form": "10-Q",
    "filed": "2026-05-01",
    "periodStart": null,
    "periodEnd": "2026-03-28",
    "frame": "CY2026Q1I",
    "accession": "0000320193-26-000013",
    "scrapedAt": "2026-06-04T20:05:11.029Z",
    "error": null
}
```

```json
{
    "cik": "CIK0000320193",
    "entityName": "Apple Inc.",
    "taxonomy": "us-gaap",
    "concept": "CashAndCashEquivalentsAtCarryingValue",
    "label": "Cash and Cash Equivalents, at Carrying Value",
    "unit": "USD",
    "value": 45572000000,
    "fiscalYear": 2026,
    "fiscalPeriod": "Q2",
    "form": "10-Q",
    "filed": "2026-05-01",
    "periodStart": null,
    "periodEnd": "2026-03-28",
    "frame": "CY2026Q1I",
    "accession": "0000320193-26-000013",
    "scrapedAt": "2026-06-04T20:05:11.030Z",
    "error": null
}
```

```json
{
    "cik": "CIK0000320193",
    "entityName": "Apple Inc.",
    "taxonomy": "us-gaap",
    "concept": "EarningsPerShareBasic",
    "label": "Earnings Per Share, Basic",
    "unit": "USD/shares",
    "value": 1.65,
    "fiscalYear": 2026,
    "fiscalPeriod": "Q2",
    "form": "10-Q",
    "filed": "2026-05-01",
    "periodStart": "2025-12-28",
    "periodEnd": "2026-03-28",
    "frame": "CY2025Q1",
    "accession": "0000320193-26-000013",
    "scrapedAt": "2026-06-04T20:05:11.030Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Reads the official SEC source, not a scraped or resold copy.
- Sends the mandatory SEC User-Agent on every request, so no 403 surprises.
- Resolves tickers to CIK for you using the live SEC ticker map.
- One flat row per fact observation, ready for analysis.
- Newest filings first, so the latest figures sit at the top.

### 📈 How it compares to alternatives

| Approach | Setup effort | Official source | Per-fact rows |
|---|---|---|---|
| This Actor | Paste tickers and run | Yes, SEC EDGAR XBRL | Yes |
| Manual EDGAR browsing | High, file by file | Yes | No, you read filings |
| Generic finance APIs | Sign up and key wrangling | Often resold data | Varies |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the SEC XBRL Company Facts Scraper in the Apify Console.
3. Enter one or more tickers or CIK numbers in `companies`.
4. Optionally narrow the run with `concepts` and `forms`, and set `maxItems`.
5. Click Start, then download your results when the run finishes.

### 💼 Business use cases

#### Equity research

| Need | How this helps |
|---|---|
| Build a revenue history | Pull Revenues and RevenueFromContractWithCustomerExcludingAssessedTax across years |
| Track profitability | Follow NetIncomeLoss and EarningsPerShareBasic by quarter |

#### Risk and credit

| Need | How this helps |
|---|---|
| Assess balance strength | Compare Assets, Liabilities, and StockholdersEquity |
| Monitor liquidity | Track CashAndCashEquivalentsAtCarryingValue over time |

#### Fintech products

| Need | How this helps |
|---|---|
| Power a fundamentals widget | Feed clean per-fact rows into your app |
| Map symbols to filings | Use the built-in ticker to CIK resolution |

#### Audit and compliance

| Need | How this helps |
|---|---|
| Verify a reported figure | Trace value, form, and accession back to the filing |
| Reconcile periods | Use fiscalYear, fiscalPeriod, and filed date together |

### 🔌 Automating SEC XBRL Company Facts Scraper

Connect the Actor to your stack so fresh financial facts flow where you need them.

- **Make** and **Zapier**: trigger a run on a schedule and route results onward.
- **Slack**: post a summary of new filings to a channel.
- **Airbyte**: load the dataset into your warehouse.
- **GitHub** and **Google Drive**: archive run outputs automatically.

### 🌟 Beyond business use cases

- **Research**: study reporting patterns across sectors and years.
- **Personal**: track the fundamentals of companies you follow.
- **Non-profit**: support transparency and financial literacy projects.
- **Experimentation**: prototype models on clean, official fundamentals.

### 🤖 Ask an AI assistant

Paste a dataset row into your favorite assistant and ask it to interpret the figures.

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

### ❓ Frequently Asked Questions

**Q: Do I need an SEC API key?**
No. SEC EDGAR XBRL data is keyless. The Actor sends the required contact User-Agent header for you.

**Q: Can I use tickers instead of CIK numbers?**
Yes. Tickers are resolved to CIK automatically using the official SEC company ticker map. You can mix tickers and CIK numbers in one run.

**Q: What concepts are pulled by default?**
Revenues, RevenueFromContractWithCustomerExcludingAssessedTax, NetIncomeLoss, Assets, Liabilities, StockholdersEquity, CashAndCashEquivalentsAtCarryingValue, and EarningsPerShareBasic.

**Q: Can I request other concepts?**
Yes. Put any us-gaap concept names in the `concepts` field and only those are returned.

**Q: How are results ordered?**
Newest first by filing date, then by fiscal year.

**Q: Why is the frame field empty on some rows?**
The SEC assigns a reporting frame only to certain observations. Rows without an assigned frame leave it empty by design.

**Q: Why is periodStart empty sometimes?**
Instant or point in time facts, such as a balance sheet figure, have an end date but no start date.

**Q: Can I filter by form type?**
Yes. Use the `forms` field, for example 10-K for annual reports or 10-Q for quarterly reports.

**Q: How many companies can I include?**
As many as you like. Each company is fetched in turn, and the overall `maxItems` cap applies across all of them.

**Q: What does a value represent?**
The reported numeric figure for that concept in the given unit, fiscal year, and period.

**Q: Is the data official?**
Yes. It comes directly from the SEC EDGAR XBRL company facts endpoint.

**Q: What is the difference between fiscalYear and the filed date?**
fiscalYear is the company reporting year the figure belongs to. filed is the calendar date the filing was submitted to the SEC.

### 🔌 Integrate with any app

Every run produces a structured dataset you can pull through the Apify API or connect to thousands of apps through the integrations above. Schedule runs to keep a rolling history of financial facts.

### 🔗 Recommended Actors

- [SEC Form 4 Scraper](https://apify.com/parseforge/sec-form4-scraper) — insider trading transactions from SEC Form 4 filings.
- [SEC 13F Holdings Scraper](https://apify.com/parseforge/sec-13f-holdings-scraper) — institutional investment manager holdings.
- [SEC Forms Scraper](https://apify.com/parseforge/sec-forms-scraper) — filing index and metadata across SEC form types.
- [FRED Scraper](https://apify.com/parseforge/fred-scraper) — economic time series from the Federal Reserve.
- [US Treasury Fiscal Data Scraper](https://apify.com/parseforge/us-treasury-fiscal-data-scraper) — federal fiscal and debt datasets.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** This is an independent tool, not affiliated with or endorsed by the U.S. Securities and Exchange Commission. Only publicly available data is collected.

# Actor input Schema

## `companies` (type: `array`):

List of stock tickers (e.g. AAPL, MSFT) or SEC CIK numbers (e.g. 320193 or 0000320193). Tickers are resolved to CIK automatically via the SEC ticker map.

## `concepts` (type: `array`):

us-gaap concept names to include. Leave empty to use the default set of common financial concepts (revenue, net income, assets, liabilities, equity, cash, EPS).

## `forms` (type: `array`):

Filter observations by SEC form type (e.g. 10-K, 10-Q). Leave empty to include all forms.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "companies": [
    "AAPL"
  ],
  "concepts": [
    "Revenues",
    "RevenueFromContractWithCustomerExcludingAssessedTax",
    "NetIncomeLoss",
    "Assets",
    "Liabilities",
    "StockholdersEquity",
    "CashAndCashEquivalentsAtCarryingValue",
    "EarningsPerShareBasic"
  ],
  "forms": [],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "companies": [
        "AAPL"
    ],
    "concepts": [
        "Revenues",
        "RevenueFromContractWithCustomerExcludingAssessedTax",
        "NetIncomeLoss",
        "Assets",
        "Liabilities",
        "StockholdersEquity",
        "CashAndCashEquivalentsAtCarryingValue",
        "EarningsPerShareBasic"
    ],
    "forms": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sec-xbrl-company-facts-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 = {
    "companies": ["AAPL"],
    "concepts": [
        "Revenues",
        "RevenueFromContractWithCustomerExcludingAssessedTax",
        "NetIncomeLoss",
        "Assets",
        "Liabilities",
        "StockholdersEquity",
        "CashAndCashEquivalentsAtCarryingValue",
        "EarningsPerShareBasic",
    ],
    "forms": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sec-xbrl-company-facts-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 '{
  "companies": [
    "AAPL"
  ],
  "concepts": [
    "Revenues",
    "RevenueFromContractWithCustomerExcludingAssessedTax",
    "NetIncomeLoss",
    "Assets",
    "Liabilities",
    "StockholdersEquity",
    "CashAndCashEquivalentsAtCarryingValue",
    "EarningsPerShareBasic"
  ],
  "forms": [],
  "maxItems": 10
}' |
apify call parseforge/sec-xbrl-company-facts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC XBRL Company Facts Scraper",
        "description": "Pull structured financial facts from SEC EDGAR by ticker or CIK number. Each row carries the company name, GAAP concept, reported value, unit, fiscal year and period, form type, and filing date. Useful for building fundamentals histories, equity research, and audit checks.",
        "version": "0.1",
        "x-build-id": "CdR1kY21vlSRczZK7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~sec-xbrl-company-facts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-sec-xbrl-company-facts-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/parseforge~sec-xbrl-company-facts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-sec-xbrl-company-facts-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/parseforge~sec-xbrl-company-facts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-sec-xbrl-company-facts-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",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies (tickers or CIKs)",
                        "type": "array",
                        "description": "List of stock tickers (e.g. AAPL, MSFT) or SEC CIK numbers (e.g. 320193 or 0000320193). Tickers are resolved to CIK automatically via the SEC ticker map.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "concepts": {
                        "title": "Concepts filter (us-gaap)",
                        "type": "array",
                        "description": "us-gaap concept names to include. Leave empty to use the default set of common financial concepts (revenue, net income, assets, liabilities, equity, cash, EPS).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "forms": {
                        "title": "Form types",
                        "type": "array",
                        "description": "Filter observations by SEC form type (e.g. 10-K, 10-Q). Leave empty to include all forms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
