# Groupon Scraper (`solidcode/groupon-scraper`) Actor

\[💰 $2.5 / 1K] Extract Groupon deals across 13 countries — titles, prices, discounts, merchant ratings, locations, and links. Search by city, category, or keyword, or paste Groupon URLs directly.

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

## Pricing

from $2.50 / 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

## Groupon Scraper

Pull live Groupon deals at scale — titles, sale and original prices, discount percentages, merchant ratings, locations with GPS coordinates, and direct deal links across 13 country sites. Search by city, category, or keyword, or paste any Groupon URL and let the scraper sort out the rest. Built for deal aggregators, affiliate marketers, and local-market researchers who need structured, up-to-date Groupon inventory without reverse-engineering city slugs and category paths by hand.

### Why This Scraper?

- **13 country Groupon sites in one actor** — United States, Canada, United Kingdom, Ireland, France, Germany, Italy, Spain, Netherlands, Belgium, Austria, Australia, and Poland, each with localized currency and the correct country category path resolved automatically.
- **Three ways to target deals** — browse a city, narrow by category slug (`restaurants`, `beauty-and-spas`, `things-to-do`, `health-and-fitness`), run a keyword search (`massage`, `oil change`, `hotel`), or paste deal/search/browse URLs directly. No hand-built links.
- **Original price, sale price, and discount % on every deal** — the full markdown story for price-comparison and savings analysis, decoded into clean numeric fields with the deal's currency code.
- **Merchant rating plus rating count** — not just a star value but the number of ratings behind it, so you can weight quality by sample size.
- **Redemption locations with street address and lat/long** — map deals geographically, with a `locationsTotal` count that flags multi-branch national chains.
- **Optional deep-detail mode** — flip `includeDetails` on to add full description, bullet highlights, fine print, units-sold, every redemption location, all purchasable option tiers, and the aggregate review summary per deal.
- **Up to your own cap, uncapped browse totals** — city and category browse feeds expose real inventory totals (often 4,000+ deals); set `maxResults` to pull exactly what you need with smooth pagination.
- **Localized text by language** — choose English, French, German, Italian, Spanish, Dutch, or Polish where a country (Canada, Belgium) ships deals in more than one language.

### Use Cases

**Deal Aggregation & Comparison**
- Populate a coupon or deals site with fresh Groupon inventory by city
- Compare sale price against original price to surface the deepest discounts
- Track which categories carry the steepest markdowns in each market
- Build "best deals near you" feeds keyed by location and GPS

**Affiliate & Lead Generation**
- Find high-discount deals worth promoting to an affiliate audience
- Pull merchant names, phones, and websites for outreach lists
- Identify highly-rated merchants running active Groupon campaigns
- Surface new local businesses entering the deals market

**Price & Market Research**
- Benchmark service pricing (massage, spa, dining) across cities and countries
- Monitor discount depth and units-sold as demand signals
- Compare the same category across the US, UK, and EU sites
- Track how a merchant's pricing and ratings move over time

**Local Business Intelligence**
- Map the density of deal-running businesses by city and category
- Profile competitor merchants in a target service vertical
- Capture redemption locations and opening hours for chains
- Analyze review volume and ratings to gauge merchant reputation

### Getting Started

#### Browse a City

The simplest run — local deals for one city:

```json
{
    "country": "us",
    "city": "chicago",
    "maxResults": 100
}
````

#### Search by Keyword

A keyword search overrides city and category:

```json
{
    "country": "us",
    "query": "massage",
    "maxResults": 200
}
```

#### Country + Category

Narrow a city's deals to a single category on a non-US site:

```json
{
    "country": "uk",
    "city": "london",
    "category": "beauty-and-spas",
    "maxResults": 150
}
```

#### Paste URLs with Full Details

Scrape exact pages and pull every detail field per deal:

```json
{
    "startUrls": [
        "https://www.groupon.com/local/chicago/food-and-drink",
        "https://www.groupon.com/deals/example-spa-chicago"
    ],
    "includeDetails": true,
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste one or more Groupon URLs — a city page, category browse page, search results page, or individual deal page. Use when you already have the exact pages you want. Leave empty to build searches with the fields below. |
| `country` | select | `United States` | Which Groupon country site to pull deals from. 13 options: US, Canada, UK, Ireland, France, Germany, Italy, Spain, Netherlands, Belgium, Austria, Australia, Poland. |
| `city` | string | `chicago` | City to browse local deals in, e.g. `chicago`, `new-york`, `london`. Leave empty for the country's national deals. |
| `category` | string | `null` | Optional category to narrow the deals, e.g. `restaurants`, `beauty-and-spas`, `things-to-do`, `health-and-fitness`. Leave empty for all categories. |
| `query` | string | `null` | Optional keyword to search for, e.g. `massage`, `oil change`, `hotel`. When set, it runs a search and takes priority over the City and Category fields. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of deals to return. The scraper stops once this many are collected. |
| `includeDetails` | boolean | `false` | Open each deal page for extra fields — full description, highlights, fine print, all merchant locations, opening hours, and review summary. Slower since every deal is fetched individually. Leave off for a faster overview of price, discount, and rating. |
| `language` | select | `English` | Preferred language for deal text where the chosen country offers more than one (e.g. Canada, Belgium). Options: English, French, German, Italian, Spanish, Dutch, Polish. |

### Output

Each deal is one row. Here's a representative result with full details enabled:

```json
{
    "title": "60-Minute Swedish Massage",
    "dealUrl": "https://www.groupon.com/deals/example-spa-chicago",
    "dealId": "a1b2c3d4-0000-0000-0000-000000000000",
    "dealSlug": "example-spa-chicago",
    "country": "us",
    "merchantName": "Lakeview Wellness Spa",
    "merchantRating": 4.7,
    "merchantRatingCount": 1240,
    "price": 49.0,
    "originalPrice": 95.0,
    "discountPercent": 48,
    "currency": "USD",
    "category": "beauty-and-spas",
    "locationName": "Lakeview Wellness Spa",
    "locationAddress": "1234 N Halsted St, Chicago, IL 60614",
    "latitude": 41.9215,
    "longitude": -87.6489,
    "locationsTotal": 2,
    "imageUrl": "https://img.grouponcdn.com/example/large.jpg",
    "description": "Relax with a full-body Swedish massage from a licensed therapist...",
    "highlights": ["Licensed massage therapists", "Aromatherapy included", "Free parking"],
    "finePrint": "Valid only for option purchased. Appointment required. Limit 1 per person.",
    "soldQuantity": "500+ bought",
    "expiryDate": "2026-12-31",
    "merchantWebsite": "https://lakeviewwellness.example.com",
    "merchantPhone": "+1 312-555-0123",
    "openingHours": "Mon-Sat 9am-8pm",
    "reviewRating": 4.6,
    "reviewCount": 318,
    "options": [
        { "title": "60-Minute Massage", "price": 49.0, "originalPrice": 95.0, "discountPercent": 48 }
    ],
    "locations": [
        { "name": "Lakeview Wellness Spa", "address": "1234 N Halsted St, Chicago, IL 60614", "lat": 41.9215, "lng": -87.6489 }
    ]
}
```

#### Core Deal Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Deal title |
| `dealUrl` | string | Canonical deal URL |
| `dealId` | string | Unique Groupon deal identifier |
| `dealSlug` | string | Deal's URL slug (the human-readable identifier in the deal link) |
| `category` | string | Deal category slug |
| `country` | string | Country code the deal was collected from (e.g. `us`, `ca`, `uk`) |
| `imageUrl` | string | Primary deal image URL |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Current deal price |
| `originalPrice` | number | Pre-discount (list) price |
| `discountPercent` | number | Discount percentage off the original price |
| `currency` | string | Currency code (e.g. USD, GBP, EUR) |

#### Merchant & Ratings

| Field | Type | Description |
|-------|------|-------------|
| `merchantName` | string | Merchant / business name |
| `merchantRating` | number | Merchant star rating |
| `merchantRatingCount` | integer | Number of ratings behind the rating |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `locationName` | string | Primary redemption location name |
| `locationAddress` | string | Primary location street address |
| `latitude` | number | Primary location latitude |
| `longitude` | number | Primary location longitude |
| `locationsTotal` | integer | Total number of redemption locations |

#### Detail-Mode Fields

Populated only when `includeDetails` is enabled.

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full deal description |
| `highlights` | string\[] | Bullet-point highlights |
| `finePrint` | string | Terms and fine print |
| `soldQuantity` | string | Units-sold message |
| `expiryDate` | string | Deal expiry date |
| `merchantWebsite` | string | Merchant website URL |
| `merchantPhone` | string | Merchant phone number |
| `openingHours` | string | Opening hours, where listed |
| `reviewRating` | number | Aggregate review rating |
| `reviewCount` | integer | Number of reviews |
| `options` | object\[] | Purchasable option tiers (title, price, original price, discount) |
| `locations` | object\[] | All redemption locations (name, address, lat/long) |

### Tips for Best Results

- **Start small** — set `maxResults` to 25-50 on your first run to confirm the city, category, or keyword returns what you expect, then scale up.
- **City and category are slugs** — use hyphenated, lowercase forms exactly as they appear in Groupon URLs (`new-york`, `beauty-and-spas`), not display names like "New York" or "Beauty & Spas".
- **Keyword search wins** — when `query` is set it takes priority over `city` and `category`, so clear it if you want a clean city browse.
- **Leave details off for speed** — basic browse already returns price, discount, rating, and location. Only enable `includeDetails` when you genuinely need descriptions, fine print, all locations, or the review summary, since each deal is then fetched individually.
- **Match country to currency** — pick the `country` whose currency you want; prices come back in that site's native currency code (USD, GBP, EUR, AUD, PLN, etc.).
- **Browse totals are huge** — city and category feeds can hold thousands of deals, so a generous `maxResults` keeps paginating; keyword search tops out around 1,000 matches.
- **Paste URLs to skip slug guessing** — if you already have a Groupon page open in your browser, drop its URL into `startUrls` and the scraper detects whether it's a city, category, search, or single-deal page.

### Pricing

**From $2.50 per 1,000 results** — pay only for the deals you collect, with no surprise compute bills. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each Apify discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.28 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.80 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.00 | $26.50 | $25.00 |
| 100,000 | $300.00 | $280.00 | $265.00 | $250.00 |

A "result" is any deal row 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 deal aggregation, market research, and lead generation. Users are responsible for complying with applicable laws and Groupon's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal or merchant contact data in line with applicable privacy regulations.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more Groupon URLs to scrape directly — a city page, a category browse page, a search results page, or an individual deal page. Use this when you already have the exact pages you want. Leave empty to build searches with the fields below instead.

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

Which Groupon country site to pull deals from.

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

City to browse local deals in, e.g. 'chicago', 'new-york', 'london'. Leave empty to use the country's default/national deals.

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

Optional category to narrow the deals, e.g. 'restaurants', 'beauty-and-spas', 'things-to-do', 'health-and-fitness'. Leave empty for all categories.

## `query` (type: `string`):

Optional keyword to search for, e.g. 'massage', 'oil change', 'hotel'. When set, this runs a search and takes priority over the City and Category fields above.

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

Maximum number of deals to return. The scraper stops once this many deals are collected.

## `includeDetails` (type: `boolean`):

Open each deal page for extra fields — full description, highlights, fine print, all merchant locations, opening hours, and review summary. Slower and costs more, since every deal is fetched individually. Leave off for a faster overview of price, discount, and rating.

## `language` (type: `string`):

Preferred language for deal text, where the chosen country offers more than one.

## Actor input object example

```json
{
  "startUrls": [],
  "country": "us",
  "city": "chicago",
  "maxResults": 100,
  "includeDetails": false,
  "language": "en"
}
```

# Actor output Schema

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

Table of deals with key fields like title, price, discount, merchant rating, and link.

## `details` (type: `string`):

Full per-deal detail rows including description, highlights, fine print, opening hours, and review summary.

# 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 = {
    "startUrls": [],
    "country": "us",
    "city": "chicago",
    "maxResults": 100,
    "includeDetails": false,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/groupon-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 = {
    "startUrls": [],
    "country": "us",
    "city": "chicago",
    "maxResults": 100,
    "includeDetails": False,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/groupon-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 '{
  "startUrls": [],
  "country": "us",
  "city": "chicago",
  "maxResults": 100,
  "includeDetails": false,
  "language": "en"
}' |
apify call solidcode/groupon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Groupon Scraper",
        "description": "[💰 $2.5 / 1K] Extract Groupon deals across 13 countries — titles, prices, discounts, merchant ratings, locations, and links. Search by city, category, or keyword, or paste Groupon URLs directly.",
        "version": "1.0",
        "x-build-id": "XCtg6nc8uZuymf3he"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~groupon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-groupon-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~groupon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-groupon-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~groupon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-groupon-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": {
                    "startUrls": {
                        "title": "Groupon URLs",
                        "type": "array",
                        "description": "Paste one or more Groupon URLs to scrape directly — a city page, a category browse page, a search results page, or an individual deal page. Use this when you already have the exact pages you want. Leave empty to build searches with the fields below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "us",
                            "ca",
                            "uk",
                            "ie",
                            "fr",
                            "de",
                            "it",
                            "es",
                            "nl",
                            "be",
                            "at",
                            "au",
                            "pl"
                        ],
                        "type": "string",
                        "description": "Which Groupon country site to pull deals from.",
                        "default": "us"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to browse local deals in, e.g. 'chicago', 'new-york', 'london'. Leave empty to use the country's default/national deals."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Optional category to narrow the deals, e.g. 'restaurants', 'beauty-and-spas', 'things-to-do', 'health-and-fitness'. Leave empty for all categories."
                    },
                    "query": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Optional keyword to search for, e.g. 'massage', 'oil change', 'hotel'. When set, this runs a search and takes priority over the City and Category fields above."
                    },
                    "maxResults": {
                        "title": "Maximum Deals",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of deals to return. The scraper stops once this many deals are collected.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Deal Details",
                        "type": "boolean",
                        "description": "Open each deal page for extra fields — full description, highlights, fine print, all merchant locations, opening hours, and review summary. Slower and costs more, since every deal is fetched individually. Leave off for a faster overview of price, discount, and rating.",
                        "default": false
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "fr",
                            "de",
                            "it",
                            "es",
                            "nl",
                            "pl"
                        ],
                        "type": "string",
                        "description": "Preferred language for deal text, where the chosen country offers more than one.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```