# Manta Scraper (`solidcode/manta-scraper`) Actor

\[💰 $2.0 / 1K] Extract US small-business profiles from Manta.com: name, full address, phone, website, email, industry, description, revenue range, employee count, and year founded. Browse by US state and industry, or paste category and company URLs. Covers all 50 states plus DC across 10 industries

- **URL**: https://apify.com/solidcode/manta-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Manta Scraper

Pull US small-business profiles from Manta.com at scale — business name, full mailing address, phone, website, email, industry category, description, revenue range, employee count, and year founded, one clean row per company. Built for lead-generation teams, sales prospectors, and market researchers who need structured small-business firmographics without digging through directory pages by hand.

### Why This Scraper?

- **Nationwide coverage — all 50 US states plus DC** — target a single state, a handful, or sweep the whole country; pick states by name from the dropdown (the input field uses standard two-letter codes like `RI`, `NY`, `TX`).
- **10 featured industries, or sweep all at once** — Consumer Products & Services, Professional Services, Restaurants & Bars, Health & Medicine, Automotive, Construction, Real Estate, Financial Services, Education, and Technology; pick one, or choose "All categories" to sweep every industry in a single de-duplicated run.
- **15 firmographic fields per business** — name, category, subcategory, description, full address (street, city, state, ZIP), phone, website, email, revenue range, employee count, year founded, and the source profile URL.
- **Revenue, headcount, and founding year on every enriched profile** — not just contact data: estimated annual revenue range, employee count, and year founded come straight from each company's Manta profile.
- **Decoded direct website URLs** — the real business website, not a redirect wrapper, so your lists land ready to use.
- **Two ways to target — filters or URLs** — browse by state plus industry, or paste Manta category, state, and `/c/` company-profile URLs directly; pasted URLs take priority and honor any filters baked into them.
- **One clean row per business** — a flat, deduplicated schema with empty fields normalized to null, ready to drop into a CRM, spreadsheet, or database.
- **Unlimited or capped runs** — set a max-results cap to test, or leave it at 0 to sweep an entire state-and-industry listing end to end.

### Use Cases

**Lead Generation**
- Build targeted small-business contact lists with phone, website, and email
- Source local-business leads by industry within a specific state
- Assemble outreach lists for a single city, state, or nationwide sweep
- Refresh stale prospect lists with current Manta profile data

**Sales Prospecting**
- Qualify accounts by revenue range and employee count before outreach
- Prioritize established businesses by year founded
- Segment a territory by industry category and sub-category
- Pull a clean book of accounts for a new sales region

**Market Research**
- Map small-business density by state and industry
- Compare industry mix across multiple states
- Size a local market by counting active businesses in a category
- Track which industries dominate a given metro or state

**Competitive Analysis**
- List every competitor in a category-and-state slice
- Benchmark competitors by revenue range and headcount
- Find independent operators a national chain competes with locally
- Monitor a niche industry's roster across states

**CRM Enrichment**
- Append revenue range, employee count, and founding year to existing records
- Fill missing phone, website, and email on known accounts
- Standardize messy address data into street, city, state, and ZIP
- Enrich a single account on demand by pasting its Manta profile URL

### Getting Started

#### One State, One Industry

The simplest run — restaurants and bars in Rhode Island:

```json
{
    "states": ["RI"],
    "category": "restaurants_and_bars"
}
````

#### Multiple States With a Cap

Professional-services firms across New York and Texas, capped at 500 results:

```json
{
    "states": ["NY", "TX"],
    "category": "professional_services",
    "maxResults": 500
}
```

#### Paste Manta URLs Directly

Mix a category-and-state browse page with a single company profile — URLs take priority over the filters:

```json
{
    "searchUrls": [
        "https://www.manta.com/mb_43_C4_40/restaurants_and_bars/rhode_island",
        "https://www.manta.com/c/mx4d4pk/finn-s-harborside"
    ],
    "maxResults": 0
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrls` | string\[] | `[]` | One or more Manta.com URLs — category/state browse pages or individual `/c/` company profile pages. When provided, these take priority and the State and Category filters are ignored. |

#### Filters

Used only when no URLs are provided above.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `states` | select\[] | `[]` | One or more US states (all 50 plus the District of Columbia). Pick from the dropdown by name; the input value is the standard two-letter code (`RI`, `NY`, `TX`). Leave empty to search nationwide. With several states, the Max Results cap is shared in the order chosen — earlier states may use it up first. |
| `category` | select | `All categories` | A single industry: one of 10 featured categories, or "All categories" to sweep across all 10 industries in one run. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum business profiles to return across all sources. Set to 0 for no cap (a 50,000 safety ceiling always applies). The run stops requesting new pages once the cap is reached and keeps the full final page rather than cutting it short. Across multiple states, categories, or URLs the cap is filled in order — earlier sources may use it before later ones are reached. |

### Output

Each row is one business profile. Here's a representative result:

```json
{
    "name": "Finn's Harborside",
    "category": "Restaurants",
    "subcategory": "Eating Places",
    "description": "Waterfront restaurant serving fresh New England seafood, steaks, and craft cocktails on the harbor.",
    "address": "38 Water St",
    "city": "East Greenwich",
    "state": "RI",
    "zip": "02818",
    "phone": "(401) 884-6363",
    "website": "https://www.finnsharborside.com",
    "email": "info@finnsharborside.com",
    "revenueRange": "$2.5 to $5 million",
    "employeeCount": "20 to 49",
    "yearFounded": 1998,
    "url": "https://www.manta.com/c/mx4d4pk/finn-s-harborside"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business name |
| `category` | string | Primary industry category |
| `subcategory` | string | null | More specific industry sub-category when published |
| `description` | string | null | Business description / about text |
| `address` | string | null | Street address line |
| `city` | string | null | City |
| `state` | string | null | US state (two-letter) |
| `zip` | string | null | ZIP / postal code |
| `phone` | string | null | Primary phone number |
| `website` | string | null | Business website URL (direct, redirect wrappers removed) |
| `email` | string | null | Contact email when listed |
| `revenueRange` | string | null | Estimated annual revenue range |
| `employeeCount` | string | null | Employee count or range |
| `yearFounded` | integer | null | Year the business was founded |
| `url` | string | Manta.com profile URL for this business |

Firmographic fields — `email`, `revenueRange`, `employeeCount`, and `yearFounded` — are filled when Manta publishes them and returned as null when it doesn't.

### Tips for Best Results

- **Start with a cap, then scale** — set `maxResults` to 50–100 to confirm the data fits your needs, then raise it or set it to 0 for a full sweep.
- **Leave `maxResults` at 0 to sweep an entire slice** — a single state-and-industry listing runs end to end, keeping the full final page rather than trimming it.
- **Paste a Manta browse URL to hit an exact industry-geography slice** — copy the category-plus-state page straight from your browser to target a precise segment without rebuilding the filters by hand.
- **Enrich a single account on demand** — drop one `/c/` company-profile URL into `searchUrls` to pull just that business, fully enriched, in one run.
- **Expect richest firmographics on established businesses** — revenue range, employee count, and year founded are densest for larger, longer-running companies; very small or brand-new listings often leave them blank.
- **Pick B2B categories for denser revenue and headcount data** — Professional Services, Financial Services, and Construction tend to publish fuller firmographics than consumer categories.
- **Combine states in one run** — list several states together and the run works through each in turn, returning one merged, de-duplicated dataset. Because the Max Results cap is shared across them in order, raise the cap (or run states one at a time) when you need full coverage of every state rather than as many as the cap allows.

### Pricing

**From $2.00 per 1,000 results** — flat pay-per-result pricing, well below the cost of manually building small-business lists. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.24 | $0.225 | $0.215 | $0.20 |
| 1,000 | $2.40 | $2.25 | $2.15 | $2.00 |
| 10,000 | $24.00 | $22.50 | $21.50 | $20.00 |
| 100,000 | $240.00 | $225.00 | $215.00 | $200.00 |

A "result" is one business profile in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### 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

This actor is designed for legitimate business research, market analysis, and lead generation. Users are responsible for complying with applicable laws and Manta.com's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal contact details in line with applicable data-protection regulations.

# Actor input Schema

## `searchUrls` (type: `array`):

Paste one or more Manta.com URLs. Accepts category or state browse pages (e.g. https://www.manta.com/mb\_43\_C4\_40/restaurants\_and\_bars/rhode\_island) and individual company profile pages (e.g. https://www.manta.com/c/<id>/<company-name>). Filters built into the URL are honored as-is. When you provide URLs here, the State and Category filters below are ignored.

## `states` (type: `array`):

Limit results to one or more US states. Used only when no URLs are provided above. Leave empty to scrape businesses nationwide. With several states selected, the Max Results cap is shared in the order chosen — earlier states may use it up before later ones are reached, so raise the cap or run states one at a time for full coverage of each.

## `category` (type: `string`):

Limit results to a single industry category. Used only when no URLs are provided above. Choose 'All categories' to sweep across all 10 featured industries in one run (results are de-duplicated, so a company listed under two industries appears once).

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

Maximum number of business profiles to return across all sources. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 50,000 always applies to prevent runaway pagination; very large caps are capped to it too). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. When several states, categories, or URLs are searched, the cap is filled in the order listed — earlier sources may use it all before later ones are reached. Raise the cap (or run states separately) to guarantee coverage of each.

## Actor input object example

```json
{
  "searchUrls": [],
  "states": [],
  "category": "all",
  "maxResults": 10
}
```

# Actor output Schema

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

Table of scraped business profiles 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 = {
    "searchUrls": [],
    "states": [],
    "category": "all",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/manta-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 = {
    "searchUrls": [],
    "states": [],
    "category": "all",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/manta-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 '{
  "searchUrls": [],
  "states": [],
  "category": "all",
  "maxResults": 10
}' |
apify call solidcode/manta-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Manta Scraper",
        "description": "[💰 $2.0 / 1K] Extract US small-business profiles from Manta.com: name, full address, phone, website, email, industry, description, revenue range, employee count, and year founded. Browse by US state and industry, or paste category and company URLs. Covers all 50 states plus DC across 10 industries",
        "version": "1.0",
        "x-build-id": "sDixa3s8cCWRBGBz4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~manta-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-manta-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~manta-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-manta-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~manta-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-manta-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": {
                    "searchUrls": {
                        "title": "Manta.com URLs",
                        "type": "array",
                        "description": "Paste one or more Manta.com URLs. Accepts category or state browse pages (e.g. https://www.manta.com/mb_43_C4_40/restaurants_and_bars/rhode_island) and individual company profile pages (e.g. https://www.manta.com/c/<id>/<company-name>). Filters built into the URL are honored as-is. When you provide URLs here, the State and Category filters below are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "US States",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to one or more US states. Used only when no URLs are provided above. Leave empty to scrape businesses nationwide. With several states selected, the Max Results cap is shared in the order chosen — earlier states may use it up before later ones are reached, so raise the cap or run states one at a time for full coverage of each.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AL",
                                "AK",
                                "AZ",
                                "AR",
                                "CA",
                                "CO",
                                "CT",
                                "DE",
                                "FL",
                                "GA",
                                "HI",
                                "ID",
                                "IL",
                                "IN",
                                "IA",
                                "KS",
                                "KY",
                                "LA",
                                "ME",
                                "MD",
                                "MA",
                                "MI",
                                "MN",
                                "MS",
                                "MO",
                                "MT",
                                "NE",
                                "NV",
                                "NH",
                                "NJ",
                                "NM",
                                "NY",
                                "NC",
                                "ND",
                                "OH",
                                "OK",
                                "OR",
                                "PA",
                                "RI",
                                "SC",
                                "SD",
                                "TN",
                                "TX",
                                "UT",
                                "VT",
                                "VA",
                                "WA",
                                "WV",
                                "WI",
                                "WY",
                                "DC"
                            ],
                            "enumTitles": [
                                "Alabama",
                                "Alaska",
                                "Arizona",
                                "Arkansas",
                                "California",
                                "Colorado",
                                "Connecticut",
                                "Delaware",
                                "Florida",
                                "Georgia",
                                "Hawaii",
                                "Idaho",
                                "Illinois",
                                "Indiana",
                                "Iowa",
                                "Kansas",
                                "Kentucky",
                                "Louisiana",
                                "Maine",
                                "Maryland",
                                "Massachusetts",
                                "Michigan",
                                "Minnesota",
                                "Mississippi",
                                "Missouri",
                                "Montana",
                                "Nebraska",
                                "Nevada",
                                "New Hampshire",
                                "New Jersey",
                                "New Mexico",
                                "New York",
                                "North Carolina",
                                "North Dakota",
                                "Ohio",
                                "Oklahoma",
                                "Oregon",
                                "Pennsylvania",
                                "Rhode Island",
                                "South Carolina",
                                "South Dakota",
                                "Tennessee",
                                "Texas",
                                "Utah",
                                "Vermont",
                                "Virginia",
                                "Washington",
                                "West Virginia",
                                "Wisconsin",
                                "Wyoming",
                                "District of Columbia"
                            ]
                        },
                        "default": []
                    },
                    "category": {
                        "title": "Industry Category",
                        "enum": [
                            "all",
                            "consumer_products_and_services",
                            "professional_services",
                            "restaurants_and_bars",
                            "health_and_medicine",
                            "automotive",
                            "construction",
                            "real_estate",
                            "financial_services",
                            "education",
                            "technology"
                        ],
                        "type": "string",
                        "description": "Limit results to a single industry category. Used only when no URLs are provided above. Choose 'All categories' to sweep across all 10 featured industries in one run (results are de-duplicated, so a company listed under two industries appears once).",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of business profiles to return across all sources. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 50,000 always applies to prevent runaway pagination; very large caps are capped to it too). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. When several states, categories, or URLs are searched, the cap is filled in the order listed — earlier sources may use it all before later ones are reached. Raise the cap (or run states separately) to guarantee coverage of each.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
