# Built In Startup Scraper — Tech Stack, Industries, HQ (`foxlabs/builtin-intelligence`) Actor

Scrape startup company profiles from BuiltIn.com — tech stack, industries, headquarters city/state/country, employee size, founded year, perks, open positions, and related companies. Pick a sector preset (SaaS, Fintech, AI/ML, eCommerce, Gaming, Crypto) or paste your own URLs.

- **URL**: https://apify.com/foxlabs/builtin-intelligence.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Built In Startup Scraper — Tech Stack, Employees, Industries, Jobs

> **Also known as**: Built In scraper · builtin.com scraper · tech stack scraper · startup data · tech company firmographics · BuiltWith alternative · talent-intelligence data · company technographics · B2B company database · company data enrichment.

### What does Built In Startup Scraper do?

**Built In Startup Scraper** extracts structured tech-company profiles from [BuiltIn.com](https://builtin.com) — the directory of tech-startup ecosystems across NYC, SF, LA, Chicago, Boston, Austin, Seattle and more — as clean JSON. For any company (by name, slug, URL, or a sector preset) it pulls:

- **Tech stack** — every technology the company lists (React, Python, Docker, Snowflake, AWS…) — a **BuiltWith alternative** for the startup segment
- **Exact employee count** (from Built In's structured data, e.g. Datadog 6,500)
- **Industries** — Built In's official tag taxonomy
- **Headquarters** — city, state, country, postal code (structured)
- **Founded year**, **company description**, **website**, **logo**
- **Open jobs** — current hiring volume on the profile
- **Perks** — benefits & culture perks

Output is ready for **tech-stack-based sales targeting**, **competitive intelligence**, **talent sourcing & recruiting**, **VC sourcing**, and CRM enrichment — with full Apify platform support (API, scheduling, integrations, proxy rotation).

### Pay-as-you-go vs paid tech-data tools

| | BuiltWith / manual research | This Actor |
|---|---|---|
| **Tech stack** | BuiltWith from ~$295/mo | Included — every tech listed per company |
| **Firmographics + jobs** | Separate tools / manual | Same record: HQ, employees, founded, open jobs |
| **Access** | Subscription / login | Pay-as-you-go — no login, no contract |
| **Freshness** | Periodic | **Live** — today's Built In profile |
| **Export** | Limited | Full JSON, CSV, Excel — yours to keep |

### Quick start

Open the Actor's **Input** tab, switch to **JSON / Editor**, paste one, click **Start**.

**Specific companies — just type names** (~$0.004 each)
```json
{ "companyNames": ["Notion", "Datadog", "Asana"] }
````

**A whole sector** — curated anchors + Built In's live directory (~$0.40)

```json
{ "preset": "saas", "maxResults": 100 }
```

**Bigger sector sweep** (~$2)

```json
{ "preset": "ai-ml", "maxResults": 500 }
```

### How discovery works

- **`companyNames` / `companyUrls`** scrape exactly the companies you give.
- **A preset** seeds curated anchor companies **plus** Built In's industry directory pages (e.g. `/companies/type/artificial-intelligence`, which lists ~180 companies). With **Discovery** on (default), the Actor harvests those listings and scrapes each company, filtered to the sector by an industry-keyword whitelist so off-sector entries are dropped.
- Every run is **live** — it reflects today's Built In directory, not a stored snapshot. `Maximum companies` is always your hard cost cap.

### Why use Built In Startup Scraper?

- **Tech-stack-based sales targeting** — find startups using a given stack (e.g. Snowflake, Salesforce) and prioritize outreach.
- **Talent & recruiting** — companies + open-job volume + the exact tech they use, for sourcing and ABM personalization.
- **Competitive & market intelligence** — map a whole tech sector (AI, fintech, gaming) with employee counts and founding years.
- **CRM enrichment** — refresh tech-company records with current HQ, size and stack.
- **LLM context** — feed structured startup data into RAG pipelines.

### How to use

1. Open the Actor's **Input** tab.
2. **Either** type names in **Company names**, **or** paste URLs in **Company URLs**, **or** pick a **sector preset** (turn **Discovery** on to expand via the directory).
3. Set **Maximum companies** as your cost cap (default 100).
4. Click **Start**. Download as JSON, CSV, Excel, HTML or XML.

### Output

One record per company (Notion, trimmed):

```json
{
  "url": "https://builtin.com/company/notion",
  "name": "Notion",
  "description": "Notion blends your everyday work tools into one...",
  "website": "https://www.notion.so/product",
  "headquarters": "San Francisco, CA, US",
  "headquartersCity": "San Francisco",
  "headquartersState": "CA",
  "headquartersCountry": "US",
  "headquartersPostalCode": "94110",
  "yearFounded": 2016,
  "employees": 1000,
  "industries": ["Artificial Intelligence", "Productivity", "Software"],
  "industriesText": "Artificial Intelligence, Productivity, Software",
  "techStack": ["Golang", "JavaScript", "MySQL", "Python", "Snowflake", "TypeScript"],
  "techStackText": "Golang, JavaScript, MySQL, Python, Snowflake, TypeScript",
  "perks": ["Health Insurance", "Remote Work", "Equity"],
  "openPositions": 9,
  "scrapedAt": "2026-05-22T10:00:00.000Z"
}
```

You can download the dataset in JSON, CSV, Excel, HTML or XML.

### Data table

| Field | Description |
|---|---|
| `name` / `description` / `website` / `logo` | Company identity |
| `headquarters` + `headquartersCity` / `State` / `Country` / `PostalCode` | HQ as a string + structured parts |
| `yearFounded` | Founding year (integer) |
| `employees` | **Exact** employee count (from Built In structured data) |
| `industries[]` / `industriesText` | Industry tags as array + comma-joined string |
| `techStack[]` / `techStackText` | Technologies the company lists (array + joined string) |
| `perks[]` | Benefits & culture perks |
| `openPositions` | Current open-job count on the profile |
| `scrapedAt` | ISO timestamp |

### Pricing

Pay-per-result: **$4 per 1,000 companies** (~$0.004 each). Datacenter proxy is sufficient — no residential needed.

- 100 companies ≈ $0.40
- 1,000 companies ≈ $4
- 10,000 companies ≈ $40

### Tips

- **Type names** for a known list, or use a **preset** to sweep a whole sector.
- **Discovery off (`presetDepth: 0`)** scrapes only the curated anchors; **on** adds the live directory (hundreds per sector).
- **Concurrency** default 10 is balanced; push 20-30 for bulk runs.
- **Schedule** with Apify Scheduler to refresh a watchlist.

### FAQ, disclaimers & support

**Is Built In data publicly accessible?** Yes — Built In company profile pages are public. This Actor reads publicly available pages, no login. Always verify your use complies with Built In's Terms of Service.

**How accurate is the tech stack?** It comes from each company's own Built In profile — accurate when listed, but optional, so smaller/newer companies may list few or none. For runtime tech detection, pair with BuiltWith.

**Why are some fields empty?** Coverage varies by company; missing fields return `null` or empty arrays — the Actor returns exactly what the profile exposes, never invented values.

**Will a typed name always resolve to the right company?** Usually, but a shared name can land on a different Built In company (e.g. `monday`). Paste the exact URL in **companyUrls** when in doubt.

**Need broader B2B intelligence (revenue, valuation, M\&A)?** Use the **Owler** or **Craft.co** company scrapers instead — Built In is tech-startup focused.

For feedback or a custom solution, open an issue in the Actor's **Issues** tab.

### 🔗 foXLabs B2B Intelligence Suite

Three company-intelligence scrapers that work better together — match results by company **domain** for a 360° view:

| Actor | Best for |
|---|---|
| [**Owler** — Company Data, Revenue, Competitors & Funding](https://apify.com/foxlabs/owler-intelligence) | Firmographics, competitors, funding & news |
| [**Craft.co** — Financials, Valuation & M\&A](https://apify.com/foxlabs/craft-intelligence) | Revenue/income statements, valuation, acquisitions, executives |
| [**Built In** — Tech Stack, Employees & Jobs](https://apify.com/foxlabs/builtin-intelligence) | Tech stack, exact headcount & hiring signals |
| [**Indian Company Data**](https://apify.com/foxlabs/indian-company-data) | 🇮🇳 India: CIN, directors, financials & charges (MCA/Tofler) |
| [**Company Data Enrichment**](https://apify.com/foxlabs/company-enrichment) | Bulk firmographics by name/domain — industry, HQ, size, revenue |
| [**Free Company Lookup**](https://apify.com/foxlabs/company-lookup-free) | 🆓 Quick basics — domain, industry, HQ, logo (start here) |

***

### Keywords / search terms

Built In, builtin.com scraper, tech stack scraper, BuiltWith alternative, startup data, tech company data, company firmographics, employee count, tech company list, B2B data, sales prospecting, talent intelligence, recruiting data, competitive intelligence, VC research, startup directory, CRM enrichment.

# Actor input Schema

## `preset` (type: `string`):

Pick a sector — we seed curated anchor companies PLUS Built In's live industry directory (e.g. /companies/type/artificial-intelligence) and scrape every company found, filtered to the sector. Every run is live (today's directory, not a frozen list). Use `Discovery` to turn directory expansion on/off and `Maximum companies` to cap scope.

## `presetDepth` (type: `integer`):

0 = scrape only the curated anchor companies. 1+ = ALSO discover companies from the sector's Built In directory pages (hundreds per sector), filtered to the sector. 'Maximum companies' is always the hard cap.

## `companyNames` (type: `array`):

Type Built In company names — one per line (e.g. `Notion`, `Datadog`). Each resolves to its Built In page (name lowercased + hyphenated). ⚠ A shared/ambiguous name can land on the wrong company (e.g. `monday` is a different company on Built In, not monday.com) — paste the exact URL below when in doubt.

## `companyUrls` (type: `array`):

Use this for exact URLs or to upload a .txt/.csv of many companies, e.g. `https://builtin.com/company/notion`.

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

Hard cap on results — pay-per-result pricing scales linearly. Set 0 for unlimited.
• 100 ≈ $0.40
• 1,000 ≈ $4
• 10,000 ≈ $40

## `maxConcurrency` (type: `integer`):

How many company pages to fetch in parallel. Default `10` is balanced; push 20-30 for bulk runs.

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

Apify Datacenter proxy is sufficient for Built In.

## Actor input object example

```json
{
  "preset": "",
  "presetDepth": 2,
  "companyNames": [
    "Notion",
    "Datadog",
    "Asana"
  ],
  "companyUrls": [],
  "maxResults": 100,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "presetDepth": 2,
    "companyNames": [
        "Notion",
        "Datadog",
        "Asana"
    ],
    "companyUrls": [],
    "maxResults": 100,
    "maxConcurrency": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/builtin-intelligence").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 = {
    "presetDepth": 2,
    "companyNames": [
        "Notion",
        "Datadog",
        "Asana",
    ],
    "companyUrls": [],
    "maxResults": 100,
    "maxConcurrency": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/builtin-intelligence").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 '{
  "presetDepth": 2,
  "companyNames": [
    "Notion",
    "Datadog",
    "Asana"
  ],
  "companyUrls": [],
  "maxResults": 100,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call foxlabs/builtin-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Built In Startup Scraper — Tech Stack, Industries, HQ",
        "description": "Scrape startup company profiles from BuiltIn.com — tech stack, industries, headquarters city/state/country, employee size, founded year, perks, open positions, and related companies. Pick a sector preset (SaaS, Fintech, AI/ML, eCommerce, Gaming, Crypto) or paste your own URLs.",
        "version": "0.1",
        "x-build-id": "QLIYOn4lNMb8xTDPZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foxlabs~builtin-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foxlabs-builtin-intelligence",
                "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/foxlabs~builtin-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-foxlabs-builtin-intelligence",
                "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/foxlabs~builtin-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-foxlabs-builtin-intelligence",
                "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": {
                    "preset": {
                        "title": "Quick start: pick a sector preset",
                        "enum": [
                            "",
                            "saas",
                            "fintech",
                            "ai-ml",
                            "ecommerce",
                            "gaming",
                            "crypto-web3"
                        ],
                        "type": "string",
                        "description": "Pick a sector — we seed curated anchor companies PLUS Built In's live industry directory (e.g. /companies/type/artificial-intelligence) and scrape every company found, filtered to the sector. Every run is live (today's directory, not a frozen list). Use `Discovery` to turn directory expansion on/off and `Maximum companies` to cap scope.",
                        "default": ""
                    },
                    "presetDepth": {
                        "title": "Discovery (preset mode)",
                        "minimum": 0,
                        "maximum": 4,
                        "type": "integer",
                        "description": "0 = scrape only the curated anchor companies. 1+ = ALSO discover companies from the sector's Built In directory pages (hundreds per sector), filtered to the sector. 'Maximum companies' is always the hard cap.",
                        "default": 2
                    },
                    "companyNames": {
                        "title": "Company names or slugs (no URL needed)",
                        "type": "array",
                        "description": "Type Built In company names — one per line (e.g. `Notion`, `Datadog`). Each resolves to its Built In page (name lowercased + hyphenated). ⚠ A shared/ambiguous name can land on the wrong company (e.g. `monday` is a different company on Built In, not monday.com) — paste the exact URL below when in doubt.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyUrls": {
                        "title": "Or paste full Built In URLs (tricky slugs / bulk file)",
                        "type": "array",
                        "description": "Use this for exact URLs or to upload a .txt/.csv of many companies, e.g. `https://builtin.com/company/notion`.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum number of companies to scrape",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard cap on results — pay-per-result pricing scales linearly. Set 0 for unlimited.\n• 100 ≈ $0.40\n• 1,000 ≈ $4\n• 10,000 ≈ $40",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Concurrent page fetches",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many company pages to fetch in parallel. Default `10` is balanced; push 20-30 for bulk runs.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Datacenter proxy is sufficient for Built In.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
