# Yelp Business Data Scraper - Phone, Address, Hours & Leads (`k1ra/yelp-business-data-scraper`) Actor

Yelp business listings scraper & Yelp data extractor: get the complete business record, not just a link. 20+ fields — phone, full address, hours, price, rating, reviews, categories, coordinates, website. Search by term + location or direct URLs. No proxy setup. Pay per business, $0 on empty.

- **URL**: https://apify.com/k1ra/yelp-business-data-scraper.md
- **Developed by:** [Kevin Savani](https://apify.com/k1ra) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 businesses

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

## Yelp Business Data Scraper — Phone, Address, Hours & Leads

**Yelp Business Data Scraper** extracts the **complete Yelp business record** — not just a link. Search Yelp by term + location, or pass direct business URLs, and get clean structured **Yelp business data** for every result: 20+ fields including name, phone, full address, hours, price, rating, review count, categories, coordinates, claimed status, menu link, and website.

Most Yelp scrapers return only a URL and a name. This one returns the **data you actually need** — phone numbers, addresses, hours, and ratings — ready for lead generation, market research, and CRM import.

> **No login, no proxy setup on your end. Pay per business — $0 on empty.** No Actor Start fee, no minimum run charge — you're never billed for businesses we don't deliver.

---

### Why Choose This Yelp Scraper

- ✅ **Complete data, not links** — 20+ fields: phone, full address, hours, price, rating, reviews count, categories, coordinates, website, menu link, claimed status.
- ✅ **Works out of the box** — no proxy to configure, no account setup. Just run it.
- ✅ **Search or direct URLs** — discover businesses by term + location, or scrape specific Yelp pages directly.
- ✅ **Fast & concurrent** — scrape many businesses in parallel, tunable concurrency.
- ✅ **Honest pricing** — pay per delivered business, **$0 on empty**, no Actor Start fee, exact `maxResults`, hard cost cap via `maxCostUsd`.
- ✅ **Clean JSON** — export to JSON, CSV, or Excel; ready for n8n, Make, and Zapier.

---

### How It Compares

| Feature | **This Scraper** | Typical Yelp Scrapers |
|---|:---:|:---:|
| Actor Start fee | ✅ None | ❌ Several charge $0.009–$0.05 per run regardless of results |
| Full record — phone, address, hours, website | ✅ One price, one event | ❌ Some split "listing" and "detail" into separate charges (2–3× effective cost) |
| Charged on empty results | ✅ $0, always | ⚠️ Varies — some bill the start fee even for zero results |
| `maxResults` enforced | ✅ Hard stop, exact count | ⚠️ Varies |
| Proxy setup required | ✅ None — built in | ⚠️ Varies, several require your own residential proxy |
| Claimed / Yelp-advertiser status | ✅ Included | ⚠️ Rarely included |

---

### Use Cases

#### Yelp Lead Generation Scraper
Use this actor as a **Yelp leads scraper** for local business outreach — pull name, phone, address, website, and category for every business matching a search term and location. Feed the output straight into a CRM or cold-outreach list without manually copying data off Yelp pages.

#### Yelp Business Data for Market Research
Run it as a **Yelp business data scraper** to size a local market: pull rating, review count, price tier, and category distribution for every business in a niche and location. Useful for franchise site selection, competitive landscape mapping, and local market sizing.

#### Yelp Competitor Analysis
Track every competitor's Yelp presence — rating, review count, price tier, hours, and claimed status — in one run. Pipe the dataset into a spreadsheet or BI tool for ongoing **Yelp competitor analysis** and local SEO benchmarking.

#### Yelp Phone Number & Contact Scraper
Extract verified phone numbers and websites for every business in a category and location — a fast **Yelp phone number scraper** for sales prospecting and directory building, without manually visiting each listing.

#### CRM & Sales Enrichment
Turn a Yelp search into a structured contact list: name, phone, full address, website, and category per business — a drop-in **lead enrichment** layer for sales and outreach tools.

#### Local SEO & Franchise Monitoring
Multi-location businesses and local SEO agencies can pull hours, claimed status, and category data across every branch or competitor location in a metro area, on a schedule, to track listing accuracy and competitive positioning over time.

---

### Who Uses This

| Use Case | Who It's For |
|---|---|
| Local business lead generation & cold outreach | Sales teams, agencies, B2B outreach tools |
| Market sizing & franchise site selection | Market researchers, franchise development teams |
| Competitor rating & pricing benchmarking | Local SEO agencies, growth teams |
| CRM / contact list enrichment | Sales ops, data teams |
| Multi-location listing monitoring | Franchise operators, local SEO agencies |

---

### Input

| Field | Description |
|---|---|
| **searchTerms** | What to search for on Yelp (e.g. `restaurants`, `plumbers`, `coffee`). Use with **location**. |
| **location** | City, state, or ZIP (e.g. `San Francisco, CA`). |
| **directUrls** | List of Yelp `/biz/...` URLs to scrape directly, instead of search. |
| **maxResults** | Maximum businesses to return — honored exactly. |
| **price** | Filter by price tier ($–$$$$). |
| **concurrency** | How many businesses to scrape in parallel. |
| **maxCostUsd** | Hard cap on total run cost. |
| **proxyConfiguration** | Optional — not required. The actor works out of the box with no proxy setup on your end. |

#### Example

```json
{
  "searchTerms": "coffee",
  "location": "San Francisco, CA",
  "maxResults": 20,
  "concurrency": 3
}
````

Or scrape specific businesses:

```json
{ "directUrls": ["https://www.yelp.com/biz/the-french-laundry-yountville-7"], "maxResults": 5 }
```

***

### Output

Each result is a clean JSON record pushed to the dataset, exportable as **JSON, CSV, or Excel**.

| Field | Description |
|---|---|
| `name` | Business name |
| `alias` / `encid` | Yelp's own slug and internal business ID |
| `phone` | Formatted phone number |
| `priceRange` | `$` to `$$$$` |
| `rating` / `reviewCount` | Star rating and total review count |
| `categories` | List of Yelp category tags |
| `address` | Street, city, region, zip, country |
| `coordinates` | Latitude / longitude |
| `timezone` | IANA timezone of the business |
| `isClaimed` | Whether the Yelp listing is claimed by the owner |
| `isYelpAdvertiser` | Whether the business runs Yelp Ads |
| `hours` | Per-day open/close hours |
| `website` | Business website, resolved from Yelp's redirect |
| `menuUrl` | Link to the Yelp-hosted menu, if any |
| `summary` | Yelp's short business summary, if present |
| `yelpUrl` | Canonical Yelp business URL |
| `primaryPhoto` / `photos` | Main photo and up to 30 photo URLs |

```json
{
  "name": "Sightglass Coffee",
  "alias": "sightglass-coffee-san-francisco-7",
  "phone": "(415) 463-1673",
  "priceRange": "$$",
  "rating": 4,
  "reviewCount": 2213,
  "categories": ["Coffee Roasteries"],
  "address": { "street": "270 Seventh St", "city": "San Francisco", "region": "CA", "zip": "94103", "country": "US" },
  "coordinates": { "lat": 37.776869, "lng": -122.408632 },
  "timezone": "America/Los_Angeles",
  "isClaimed": true,
  "isYelpAdvertiser": false,
  "hours": [
    { "day": "Mon", "hours": ["6:30 AM - 5:00 PM"] },
    { "day": "Sat", "hours": ["7:00 AM - 5:00 PM"] }
  ],
  "website": "http://www.sightglasscoffee.com",
  "yelpUrl": "https://www.yelp.com/biz/sightglass-coffee-san-francisco-7",
  "photos": ["https://s3-media0.fl.yelpcdn.com/bphoto/ETCTT8ayenbJi6DGw6VCHA/l.jpg", "..."]
}
```

`null`/empty fields are dropped, not padded with placeholders — the record only contains what Yelp actually published for that business.

***

### Proxy Setup

The actor comes with a built-in proxy that works out of the box — no configuration needed. Just run it.

Optionally, you can provide your own proxy in the **Proxy Configuration** field in the Input tab if you prefer to override it.

***

### Pricing

**$5 per 1,000 businesses scraped ($0.005 per business). $0 on empty, no Actor Start fee.**

You are billed only for businesses actually delivered to the dataset — a failed search or an unreachable listing costs nothing.

| Businesses scraped | Estimated cost |
|---|---|
| 10 | ~$0.05 |
| 100 | ~$0.50 |
| 1,000 | ~$5.00 |

***

### Schedule & Automate

Use Apify's built-in **Scheduler** to run this actor on a cron schedule — daily, weekly, or hourly — and track how ratings, review counts, and hours change over time. Connect the dataset to Google Sheets, Zapier, Make, or any webhook via the Apify API.

***

### Integrations & Automation

This **Yelp scraper** plugs into the entire Apify integrations ecosystem and any tool that speaks HTTP:

- **Make** ([formerly Integromat](https://docs.apify.com/platform/integrations/make)) — trigger Yelp scrapes from any Make scenario.
- **Zapier** ([docs](https://docs.apify.com/platform/integrations/zapier)) — pipe results into Zapier Zaps for CRM enrichment and alerting.
- **Google Sheets** — auto-export every run's dataset to a Sheet for a live lead list.
- **Slack** ([docs](https://docs.apify.com/platform/integrations/slack)) — get notified when scheduled runs complete.
- **Airbyte** ([docs](https://docs.apify.com/platform/integrations/airbyte)) — sync the dataset to your data warehouse (Snowflake, BigQuery, Redshift, Postgres).
- **Apify API** — full programmatic control via the official [`apify-client`](https://docs.apify.com/api/v2) packages for Node.js and Python, or the REST endpoints directly.
- **Webhooks** ([docs](https://docs.apify.com/platform/integrations/webhooks)) — fire any HTTP endpoint when a run finishes, fails, or finds specific data.

Build a lead-generation pipeline, a local-market dashboard, or a CRM enrichment layer on top of this actor without writing any scraping code.

#### Python example

```python
import apify_client

client = apify_client.ApifyClient("YOUR_API_TOKEN")
run = client.actor("k1ra/yelp-business-data-scraper").call(run_input={
    "searchTerms": "coffee",
    "location": "San Francisco, CA",
    "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item.get("phone"), item.get("rating"))
```

***

### FAQ

**Do I need to log in?** No — no Yelp account or cookies required.

**Do I need to configure a proxy?** No — the actor works out of the box with no proxy setup on your end.

**What if a search returns nothing?** You pay **$0** — billing is per delivered business only, no Actor Start fee.

**Can I scrape specific businesses?** Yes — pass their Yelp URLs in `directUrls` for guaranteed, exact results instead of search discovery.

**What happens if a business page fails to load?** It's skipped, not billed, and the run continues — check the run log for which URLs were skipped and why.

**Can I filter by price tier?** Yes — use the `price` input to only return `$`, `$$`, `$$$`, or `$$$$` businesses.

**How many businesses can I scrape in one run?** As many as `maxResults` allows; use `concurrency` to control run speed and `maxCostUsd` to hard-cap spend.

**Can I export to a spreadsheet?** Yes. After the run completes, go to **Storage → Dataset → Export** and choose CSV or Excel, or auto-export to **Google Sheets** via the Apify integration.

**Can I run this via API?** Yes — use the Apify API or the official SDKs (JavaScript, Python) to trigger runs and retrieve results programmatically.

**Is it legal to scrape public Yelp business listings?** The actor only extracts **publicly available data** shown on public Yelp business pages. It does not bypass any login wall or extract private content. You are responsible for compliance with Yelp's Terms of Service and applicable laws when using the extracted data.

***

### ⭐ Bookmark this Actor & Leave a Review

If this **Yelp business scraper** saves you time:

- **⭐ Click the star** at the top of the actor page to bookmark it — makes it easier for you to find later and helps other Apify users discover it.
- **📝 Leave a review** — even one sentence on what you use it for helps prioritize the next feature.

***

### Related Apify Actors

Looking for more lead-gen and data-extraction power? You may also like:

- [Indeed Jobs Scraper](https://apify.com/k1ra/indeed-jobs-scraper) — full job descriptions, salary, no login
- [LinkedIn Jobs Scraper](https://apify.com/k1ra/linkedin-jobs-scraper) — bulk job search, no cookies
- [Naukri + Gulf Jobs Scraper](https://apify.com/k1ra/naukri-jobs-scraper) — India + Gulf jobs, AmbitionBox ratings
- [Yelp Scrapers](https://apify.com/store?search=yelp%20scraper) — the full Apify Yelp scraping catalog
- [Lead Generation Tools](https://apify.com/store?category=LEAD_GENERATION) — more B2B lead enrichment actors
- [Business Data Scrapers](https://apify.com/store?category=BUSINESS) — company and business data extraction tools

***

### Support & Feedback

Found a bug or want a new field supported?

- **Open an issue** on the actor's Issues tab in the Apify Console.
- **Feature requests** are welcome — especially for additional fields or filters.

# Actor input Schema

## `searchTerms` (type: `string`):

What to search for (e.g. restaurants, plumbers, coffee). Use with Location. Leave empty if using Direct URLs.

## `location` (type: `string`):

City, state, or ZIP to search within (e.g. San Francisco, CA). Required with Search term.

## `directUrls` (type: `array`):

Optional list of Yelp /biz/ URLs to scrape directly, bypassing search.

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

Maximum businesses to return. Honored exactly; you are never charged for more.

## `price` (type: `array`):

Only return businesses in these price tiers ($ = 1 to $$$$ = 4).

## `maxCostUsd` (type: `integer`):

Hard cap on total run cost; the run stops before exceeding it. 0 = no cap.

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

Not required — this actor works out of the box with no proxy setup on your end. Leave as-is unless you specifically need to override it.

## Actor input object example

```json
{
  "searchTerms": "coffee",
  "location": "San Francisco, CA",
  "directUrls": [],
  "maxResults": 20,
  "maxCostUsd": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchTerms": "coffee",
    "location": "San Francisco, CA",
    "directUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("k1ra/yelp-business-data-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchTerms": "coffee",
    "location": "San Francisco, CA",
    "directUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("k1ra/yelp-business-data-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": "coffee",
  "location": "San Francisco, CA",
  "directUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call k1ra/yelp-business-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yelp Business Data Scraper - Phone, Address, Hours & Leads",
        "description": "Yelp business listings scraper & Yelp data extractor: get the complete business record, not just a link. 20+ fields — phone, full address, hours, price, rating, reviews, categories, coordinates, website. Search by term + location or direct URLs. No proxy setup. Pay per business, $0 on empty.",
        "version": "0.1",
        "x-build-id": "wwEOHBf6u2LuPUFdS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/k1ra~yelp-business-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-k1ra-yelp-business-data-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/k1ra~yelp-business-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-k1ra-yelp-business-data-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/k1ra~yelp-business-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-k1ra-yelp-business-data-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search term",
                        "type": "string",
                        "description": "What to search for (e.g. restaurants, plumbers, coffee). Use with Location. Leave empty if using Direct URLs."
                    },
                    "location": {
                        "title": "Location (city or ZIP)",
                        "type": "string",
                        "description": "City, state, or ZIP to search within (e.g. San Francisco, CA). Required with Search term."
                    },
                    "directUrls": {
                        "title": "Direct business URLs",
                        "type": "array",
                        "description": "Optional list of Yelp /biz/ URLs to scrape directly, bypassing search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum businesses to return. Honored exactly; you are never charged for more.",
                        "default": 20
                    },
                    "price": {
                        "title": "Price filter",
                        "type": "array",
                        "description": "Only return businesses in these price tiers ($ = 1 to $$$$ = 4).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4"
                            ],
                            "enumTitles": [
                                "$",
                                "$$",
                                "$$$",
                                "$$$$"
                            ]
                        }
                    },
                    "maxCostUsd": {
                        "title": "Max cost (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total run cost; the run stops before exceeding it. 0 = no cap.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional)",
                        "type": "object",
                        "description": "Not required — this actor works out of the box with no proxy setup on your end. Leave as-is unless you specifically need to override it.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
