# Fyple Scraper - Local Business Directory (`crawlerbros/fyple-scraper`) Actor

Scrape Fyple, a local business directory covering the US, UK, Canada, South Africa, New Zealand, Australia, and Ireland. Browse by category, region and city, run a keyword search, or fetch full business profiles by URL. Get names, addresses, phone numbers, emails, websites, ratings, and more.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Fyple Scraper - Local Business Directory

Scrape **Fyple** — a local business directory covering the **United States, United Kingdom, Canada, South Africa, New Zealand, Australia, and Ireland**. Browse any business category (optionally narrowed to a region and city), run a free-text keyword search, or fetch full business profiles by direct URL. Get names, addresses, phone numbers, emails, websites, categories, ratings, opening hours, accepted payment types, and GPS coordinates. No login, no cookies, no API key required.

### What this actor does

- **Three modes:** `search` (category browse, optionally narrowed to region/city), `keyword` (free-text business name/type + location search), and `byUrl` (direct business profile URLs)
- **7 countries** — United States, United Kingdom, Canada, South Africa, New Zealand, Australia, Ireland — each its own directory edition
- **50+ curated categories** across 18 industry groups, or type any custom `parent-group/subcategory` path (Fyple has 500+ subcategories)
- **Region and city filters** to narrow a category browse down to a state/province and city, with full pagination
- **Filter by** minimum star rating (1-5)
- **Rich business profiles** — street address, phone, mobile, fax, email, website, categories, rating, review count, individual customer reviews, opening hours, accepted payment types, description, photo gallery, social/review-site links, and GPS coordinates
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `name` — business name
- `streetAddress`, `city`, `region`, `postalCode`, `country` — full postal address
- `phone`, `mobile`, `fax` — contact numbers (when published)
- `email` — decoded from the business's published contact details
- `website` — the business's own website
- `category` — primary (most specific) listed category, `categories[]` — every category breadcrumb chain the business is listed under
- `rating`, `reviewCount` — average star rating (1-5) and number of reviews
- `reviews[]` — individual customer reviews (`{author, rating, text, date}` per review, up to 20 most recent), when the business has any
- `description` — the business's own full description (falls back to Fyple's page summary when a business hasn't written one)
- `images[]` — photo gallery URLs, when the business has uploaded photos
- `openingHours[]` — structured opening hours (`{day, hours}` per day, when published)
- `acceptedPayments[]` — payment types the business accepts (e.g. Visa, PayPal, Cash), when published
- `employeeCount`, `yearEstablished` — company size and founding year, when the business has published them
- `amenities[]` — business amenity flags the owner has ticked (e.g. Parking Available, Wi-Fi, Wheelchair Access, Takeaway & Delivery, Female Friendly), when published
- `facebookUrl`, `yelpUrl`, `twitterUrl`, `instagramUrl`, `linkedinUrl`, `pinterestUrl`, `youtubeUrl` — social media and review-site profile links, when published
- `keywords[]` — search keyword tags the business has associated with its listing, when published
- `latitude`, `longitude` — GPS coordinates from the business's map listing
- `logoUrl` — business logo/photo
- `nearbyBusinesses[]` — other businesses located close by (`{name, url, address, distance}`), useful for competitor/area mapping
- `sourceUrl` — canonical Fyple profile URL for the business
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `search` | `search` (category browse), `keyword` (free-text search), or `byUrl` (fetch by URL) |
| `country` | string (select) | `us` | Which Fyple country edition to scrape: `us`, `gb`, `ca`, `za`, `nz`, `au`, `ie` |
| `category` | string (select) | `food-drink/restaurant` | Pick a common category, or `custom` to use `customCategory` (mode=search) |
| `customCategory` | string | – | Free-text `parent-group/subcategory` path, overrides `category` (mode=search) |
| `region` | string | – | State/province to narrow the browse to, e.g. `ca` or `on` (mode=search) |
| `city` | string | – | City to narrow the browse to; requires `region` to also be set (mode=search) |
| `keyword` | string | `Pizza` | Business name or type to search for (mode=keyword) |
| `location` | string | `New York` | City, state, or ZIP to search near (mode=keyword) |
| `businessUrls` | array | – | Fyple profile URLs to fetch directly (mode=byUrl) |
| `minRating` | integer | `0` (no minimum) | Only return businesses rated at least 1-5 stars |
| `maxItems` | int | `20` | Hard cap on returned records (1-2000) |

#### Example: restaurants nationwide in the US

```json
{
  "mode": "search",
  "country": "us",
  "category": "food-drink/restaurant",
  "maxItems": 30
}
````

#### Example: lawyers in Ontario, Canada

```json
{
  "mode": "search",
  "country": "ca",
  "category": "legal-financial/lawyer",
  "region": "on",
  "maxItems": 50
}
```

#### Example: 4+ star dentists in Los Angeles, California

```json
{
  "mode": "search",
  "country": "us",
  "category": "health-beauty/dentist",
  "region": "ca",
  "city": "Los Angeles",
  "minRating": 4,
  "maxItems": 40
}
```

#### Example: keyword search for plumbers in London, UK

```json
{
  "mode": "keyword",
  "country": "gb",
  "keyword": "Plumber",
  "location": "London",
  "maxItems": 20
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "byUrl",
  "businessUrls": [
    { "url": "https://www.fyple.com/company/tanlite-ibras8x/" }
  ]
}
```

### Use cases

- **Local lead generation** — build a prospect list of businesses by trade, region, and city for B2B outreach
- **Market research** — measure business density and average ratings for a category across markets
- **Directory aggregation** — feed structured local-business data into your own local-search product
- **Competitor mapping** — see who else operates in a category and area, with ratings and contact info
- **Multi-country expansion research** — compare category coverage across the US, UK, Canada, South Africa, New Zealand, Australia, and Ireland

### Limitations

- **Keyword search returns a single page.** Fyple's free-text `keyword` search does not expose further pagination in its results page, so `mode=keyword` returns up to ~20 results per run. For larger volumes, use `mode=search` (category browse), which paginates fully.
- **Category browsing requires a curated or custom category path.** Fyple's free-text search endpoint occasionally rejects unusual keyword/location combinations; `mode=search` (category + optional region/city) is the more reliable bulk-scraping path and is recommended for large runs.
- **`region` is a short code, not a free-text place name.** Fyple's region URLs use short codes (e.g. `ca` for California, `on` for Ontario) rather than full names. Check a business's own `region` output field or Fyple's site navigation for the exact code for your market.
- **`minRating` is applied client-side.** A business with no rating on Fyple is only excluded once `minRating` is set above 0 (which requires a rating to compare against).
- **Opening hours, accepted payments, mobile/fax numbers, email, reviews, photos, social links, and "more details" fields (employee count, year established, keywords, amenities) are only present when the business itself has published them** — most listings have at least a name, address, and phone number, but the richer fields vary per business.
- **`reviews[]` is capped at the 20 most recent reviews per business** to keep records a manageable size; `reviewCount` still reflects the business's true total review count.

### FAQ

**What data source does this actor use?**
It reads the publicly available category-browse, search-results, and business-profile pages on Fyple. No account or API key is needed.

**Is this affiliated with Fyple?**
No. This is an independent, third-party actor that reads publicly accessible pages.

**Why do some businesses have no rating, email, or website?**
Fyple only shows a rating once a business has received at least one review, and only shows contact/social details a business itself provided. Fields with no data are simply omitted from the record rather than shown as empty or null.

**Which countries are covered?**
United States (fyple.com), United Kingdom (fyple.co.uk), Canada (fyple.ca), South Africa (fyple.co.za), New Zealand (fyple.co.nz), Australia (fyple.biz), and Ireland (fyple.net) — set with the `country` input.

**Can I browse a category nationwide instead of a specific city?**
Yes — leave `region` and `city` blank to browse the category across the whole country.

**How accurate are the GPS coordinates?**
`latitude`/`longitude` come directly from the embedded map on the business's own Fyple profile page.

**Are individual customer reviews included?**
Yes — when a business has reviews, up to its 20 most recent are returned in `reviews[]`, each with the reviewer's name, star rating, review text, and date.

**Does this actor need a proxy or login?**
No — Fyple's category, search, and profile pages are served without any anti-bot challenge, so this actor runs entirely on Apify's free plan with no proxy and no credentials required. It optionally uses Apify's free `AUTO` proxy group to recover automatically from an occasional rate limit.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: browse a category (optionally narrowed to a region/city), run a free-text keyword search, or fetch business profiles from direct Fyple URLs.

## `country` (type: `string`):

Which Fyple country edition to scrape. Each country is a separate directory of local businesses (mode=search, mode=keyword).

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

Business category to browse. Pick a common category, or choose 'Custom category' and type your own path below (mode=search).

## `customCategory` (type: `string`):

Free-text category path in the form 'parent-group/subcategory', e.g. 'legal-financial/notary' or 'shopping-service/jewelry-store' (mode=search). Takes priority over 'Category' when set. Fyple has 500+ subcategories; browse https://www.fyple.com/categories/ to find exact slugs.

## `region` (type: `string`):

State, province, or region to narrow the category browse to, e.g. 'ca' for California or 'on' for Ontario. Optional -- omit to browse the category nationwide (mode=search).

## `city` (type: `string`):

City to narrow the category browse to, e.g. 'Los Angeles'. Requires 'Region' to also be set (mode=search).

## `keyword` (type: `string`):

Business name or type to search for, e.g. 'Pizza' or 'Plumber' (mode=keyword, required).

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

City, state, or ZIP code to search near, e.g. 'New York' or 'Los Angeles, CA' (mode=keyword).

## `businessUrls` (type: `array`):

Direct Fyple business profile URLs to fetch, e.g. https://www.fyple.com/company/some-business-abc123/. Use the 'sourceUrl' field from search results.

## `minRating` (type: `integer`):

Only return businesses rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Businesses with no rating are excluded once this is set above 0.

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

Hard cap on the number of business records to return.

## Actor input object example

```json
{
  "mode": "search",
  "country": "us",
  "category": "food-drink/restaurant",
  "keyword": "Pizza",
  "location": "New York",
  "businessUrls": [],
  "minRating": 0,
  "maxItems": 20
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped Fyple business listings.

# 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 = {
    "mode": "search",
    "country": "us",
    "category": "food-drink/restaurant",
    "keyword": "Pizza",
    "location": "New York",
    "businessUrls": [],
    "minRating": 0,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/fyple-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 = {
    "mode": "search",
    "country": "us",
    "category": "food-drink/restaurant",
    "keyword": "Pizza",
    "location": "New York",
    "businessUrls": [],
    "minRating": 0,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/fyple-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 '{
  "mode": "search",
  "country": "us",
  "category": "food-drink/restaurant",
  "keyword": "Pizza",
  "location": "New York",
  "businessUrls": [],
  "minRating": 0,
  "maxItems": 20
}' |
apify call crawlerbros/fyple-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fyple Scraper - Local Business Directory",
        "description": "Scrape Fyple, a local business directory covering the US, UK, Canada, South Africa, New Zealand, Australia, and Ireland. Browse by category, region and city, run a keyword search, or fetch full business profiles by URL. Get names, addresses, phone numbers, emails, websites, ratings, and more.",
        "version": "1.0",
        "x-build-id": "s917oAVwPA1dHcG6L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~fyple-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-fyple-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/crawlerbros~fyple-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-fyple-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/crawlerbros~fyple-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-fyple-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode",
                    "country"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "keyword",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch: browse a category (optionally narrowed to a region/city), run a free-text keyword search, or fetch business profiles from direct Fyple URLs.",
                        "default": "search"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "gb",
                            "ca",
                            "za",
                            "nz",
                            "au",
                            "ie"
                        ],
                        "type": "string",
                        "description": "Which Fyple country edition to scrape. Each country is a separate directory of local businesses (mode=search, mode=keyword).",
                        "default": "us"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "custom",
                            "food-drink/restaurant",
                            "food-drink/cafe",
                            "food-drink/bar-and-pub",
                            "food-drink/catering",
                            "food-drink/pizza-delivery",
                            "automotive/auto-repair-service",
                            "automotive/auto-dealer",
                            "automotive/auto-rental",
                            "automotive/auto-insurance",
                            "automotive/tire",
                            "health-beauty/dentist",
                            "health-beauty/doctor-and-clinic",
                            "health-beauty/beauty-salon",
                            "health-beauty/alternative-medicine",
                            "health-beauty/optician",
                            "legal-financial/lawyer",
                            "legal-financial/accounting",
                            "legal-financial/banking",
                            "legal-financial/financial-service",
                            "legal-financial/legal-service",
                            "home-garden/cleaning-service",
                            "home-garden/appliance",
                            "home-garden/carpet-store",
                            "home-garden/fence-supply-store",
                            "home-garden/home-remodeling-repair",
                            "construction-contractor/builder",
                            "construction-contractor/architectural-service",
                            "construction-contractor/electrician",
                            "construction-contractor/plumber",
                            "computer-electronics/computer-repair-service",
                            "computer-electronics/computer-store",
                            "computer-electronics/cell-phone-store",
                            "real-estate/estate-agent",
                            "real-estate/property-management",
                            "shopping-service/clothing-and-accessory",
                            "shopping-service/book",
                            "shopping-service/antique-collectible",
                            "business-service/consultant",
                            "business-service/courier-service",
                            "education/school",
                            "education/higher-education",
                            "sport-recreation/fitness",
                            "sport-recreation/massage",
                            "travel-accommodation/accommodation",
                            "travel-accommodation/resort",
                            "travel-accommodation/tour-operator",
                            "organisations-government/charity",
                            "organisations-government/church-mosque-and-synagogue",
                            "pet-animal/animal-shelter",
                            "pet-animal/animal-healthcare",
                            "arts-entertainment/entertainment",
                            "arts-entertainment/event-planning",
                            "industry-agriculture/farmer-market"
                        ],
                        "type": "string",
                        "description": "Business category to browse. Pick a common category, or choose 'Custom category' and type your own path below (mode=search).",
                        "default": "food-drink/restaurant"
                    },
                    "customCategory": {
                        "title": "Custom category path (overrides selection above)",
                        "type": "string",
                        "description": "Free-text category path in the form 'parent-group/subcategory', e.g. 'legal-financial/notary' or 'shopping-service/jewelry-store' (mode=search). Takes priority over 'Category' when set. Fyple has 500+ subcategories; browse https://www.fyple.com/categories/ to find exact slugs."
                    },
                    "region": {
                        "title": "Region / state / province",
                        "type": "string",
                        "description": "State, province, or region to narrow the category browse to, e.g. 'ca' for California or 'on' for Ontario. Optional -- omit to browse the category nationwide (mode=search)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to narrow the category browse to, e.g. 'Los Angeles'. Requires 'Region' to also be set (mode=search)."
                    },
                    "keyword": {
                        "title": "Keyword (what)",
                        "type": "string",
                        "description": "Business name or type to search for, e.g. 'Pizza' or 'Plumber' (mode=keyword, required)."
                    },
                    "location": {
                        "title": "Location (where)",
                        "type": "string",
                        "description": "City, state, or ZIP code to search near, e.g. 'New York' or 'Los Angeles, CA' (mode=keyword)."
                    },
                    "businessUrls": {
                        "title": "Business profile URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Direct Fyple business profile URLs to fetch, e.g. https://www.fyple.com/company/some-business-abc123/. Use the 'sourceUrl' field from search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Fyple business profile URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return businesses rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Businesses with no rating are excluded once this is set above 0.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
