# Efood Scraper - Greek Food Delivery Restaurants & Prices (`studio-amba/efood-scraper`) Actor

Scrape restaurants, ratings, delivery info, cuisines, and prices from efood.gr — Greece's largest food delivery platform with 20,000+ stores.

- **URL**: https://apify.com/studio-amba/efood-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Efood Scraper - Restaurants & Delivery Data from Greece's #1 Food Platform

Extract restaurant data, ratings, delivery times, cuisines, pricing, and availability from [efood.gr](https://www.e-food.gr) — Greece's dominant food delivery platform (Delivery Hero) with 20,000+ stores across 100+ cities.

### What is Efood Scraper?

Efood Scraper collects structured restaurant and store data from efood.gr's public API. It returns detailed information for every restaurant available for delivery at a given location — including ratings, delivery time estimates, minimum order amounts, delivery fees, cuisine types, opening hours, offers, and full address data with coordinates.

Efood (e-food.gr) is Greece's largest food delivery service, owned by Delivery Hero. It dominates the Greek market with over 20,000 partner stores covering restaurants, supermarkets, pharmacies, and retail shops across 100+ cities. No other food delivery platform comes close in Greece.

**No login or cookies required.** This actor uses efood's public restaurant listing API.

**Popular use cases:**

- **Market research** — Map the Greek food delivery landscape. Analyze restaurant density, cuisine distribution, and pricing by city or neighborhood.
- **Competitive intelligence** — Track delivery fees, minimum orders, and ratings across competing restaurants in any Greek city.
- **Location analytics** — Identify underserved areas, popular cuisines by neighborhood, and delivery coverage gaps.
- **Price monitoring** — Monitor delivery costs, minimum order thresholds, and promotional offers across the platform.
- **Investment research** — Analyze the Greek food delivery market for investment due diligence or franchise opportunities.

### How to scrape Efood data

#### Option 1: Search by city name

Set `location` to any major Greek city. The scraper automatically resolves city names to coordinates.

**Supported cities include:** Athens, Thessaloniki, Heraklion, Patras, Larissa, Volos, Ioannina, Chania, Kavala, Rhodes, Corfu, Piraeus, Kalamata, Mykonos, Santorini, and 20+ more.

#### Option 2: Search by exact coordinates

Provide `latitude` and `longitude` for precise location control. This is useful for targeting specific neighborhoods or areas not in the built-in city list.

#### Option 3: Filter by cuisine or keyword

Add a `searchQuery` to filter by restaurant name or cuisine keyword (e.g., "pizza", "souvlaki", "McDonald's"). Use `cuisineFilter` for exact cuisine type matching (e.g., "Burgers", "Sushi", "Souvlakia").

#### Input parameters

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | String | — | Filter restaurants by name, cuisine, or address keyword |
| `location` | String | `Athens` | City name (Athens, Thessaloniki, Heraklion, etc.) |
| `latitude` | Number | — | Exact latitude (overrides location) |
| `longitude` | Number | — | Exact longitude (overrides location) |
| `cuisineFilter` | String | — | Exact cuisine type filter (Pizza, Burgers, Sushi, etc.) |
| `onlyOpen` | Boolean | `false` | Only return currently open restaurants |
| `maxResults` | Integer | `100` | Maximum restaurants to return (up to 50,000) |
| `proxyConfiguration` | Object | — | Proxy settings (Greek residential recommended) |

**Tips:**
- The default location is Athens city center. Change it to target other Greek cities.
- Efood returns ALL restaurants available for delivery at the given coordinates — this can be 1,000-4,000+ in large cities.
- Use `maxResults` to limit output. Set it high (e.g., 10,000) for full city dumps.
- The `onlyOpen` filter is time-dependent — results change based on when you run the scraper.
- Cuisine names are in Greek on efood. Common ones: "Souvlakia" (souvlaki), "Pizza", "Burgers", "Sushi", "Ελληνική" (Greek), "Ασιατική" (Asian), "Ιταλική" (Italian).

### What data does Efood Scraper extract?

Each restaurant includes:

| Field | Type | Example |
|-------|------|---------|
| `name` | String | `"McDonald's"` |
| `efoodId` | Number | `1803651` |
| `cuisines` | Array | `["Burgers"]` |
| `primaryCuisine` | String | `"Burgers"` |
| `rating` | Number | `4.7` |
| `reviewCount` | Number | `10418` |
| `deliveryTimeMin` | Number | `30` |
| `minimumOrder` | Number | `0` |
| `deliveryCost` | Number | `0` |
| `freeDelivery` | Boolean | `true` |
| `isOpen` | Boolean | `true` |
| `hasPickup` | Boolean | `false` |
| `hasCashOnDelivery` | Boolean | `true` |
| `hasCreditCard` | Boolean | `true` |
| `address` | String | `"Ermou 2, Syntagma 10563"` |
| `street` | String | `"Ermou 2"` |
| `area` | String | `"Syntagma"` |
| `city` | String | `"Athens"` |
| `postalCode` | String | `"10563"` |
| `latitude` | Number | `37.9758` |
| `longitude` | Number | `23.7337` |
| `phone` | String | `"+302113110700"` |
| `logoUrl` | String | Restaurant logo URL |
| `coverUrl` | String | Restaurant cover image URL |
| `chainName` | String | `"McDonald's"` |
| `vertical` | String | `"food"` |
| `isNew` | Boolean | `false` |
| `hasOffers` | Boolean | `true` |
| `offers` | Array | `["1+1 Deal"]` |
| `timetable` | Object | Opening hours by day |
| `distance` | Number | `1041` (meters from search point) |
| `slug` | String | `"/athina/mcdonald-s"` |
| `url` | String | Full restaurant URL on efood.gr |
| `scrapedAt` | String | ISO timestamp |

### Example output

```json
[
  {
    "name": "McDonald's",
    "efoodId": 1803651,
    "cuisines": ["Burgers"],
    "primaryCuisine": "Burgers",
    "rating": 4.7,
    "reviewCount": 10418,
    "deliveryTimeMin": 30,
    "minimumOrder": 0,
    "deliveryCost": 0,
    "freeDelivery": true,
    "isOpen": true,
    "hasPickup": false,
    "hasCashOnDelivery": true,
    "hasCreditCard": true,
    "address": "Ermou 2, Syntagma 10563",
    "street": "Ermou 2",
    "area": "Syntagma",
    "city": "Athens",
    "postalCode": "10563",
    "latitude": 37.9758132,
    "longitude": 23.7336797,
    "phone": "+302113110700",
    "chainName": "McDonald's",
    "vertical": "food",
    "isNew": false,
    "hasOffers": true,
    "offers": ["1+1 Deal"],
    "timetable": {
      "monday": "06:00-06:00",
      "tuesday": "06:00-06:00",
      "wednesday": "06:00-06:00",
      "thursday": "06:00-06:00",
      "friday": "06:00-06:00",
      "saturday": "06:00-06:00",
      "sunday": "06:00-06:00"
    },
    "distance": 1041,
    "slug": "/athina/mcdonald-s",
    "url": "https://www.e-food.gr/athina/mcdonald-s",
    "scrapedAt": "2026-06-07T14:30:00.000Z"
  },
  {
    "name": "Domino's Pizza",
    "efoodId": 5707412,
    "cuisines": ["Pizza", "Pasta"],
    "primaryCuisine": "Pizza",
    "rating": 4.6,
    "reviewCount": 3842,
    "deliveryTimeMin": 35,
    "minimumOrder": 5,
    "deliveryCost": 1.5,
    "freeDelivery": false,
    "isOpen": true,
    "hasPickup": true,
    "hasCashOnDelivery": true,
    "hasCreditCard": true,
    "address": "Stadiou 28, Athens 10564",
    "street": "Stadiou 28",
    "area": "Athens Center",
    "city": "Athens",
    "postalCode": "10564",
    "latitude": 37.9795,
    "longitude": 23.7312,
    "phone": "+302103259000",
    "chainName": "Domino's Pizza",
    "vertical": "food",
    "isNew": false,
    "hasOffers": true,
    "offers": ["Heineken Deals"],
    "distance": 580,
    "slug": "/athina/domino-s-pizza",
    "url": "https://www.e-food.gr/athina/domino-s-pizza",
    "scrapedAt": "2026-06-07T14:30:02.000Z"
  }
]
````

### How much does it cost?

Efood Scraper uses direct API calls (no browser needed), making it extremely fast and cheap.

| Scenario | Restaurants | Estimated cost | Time |
|----------|-------------|---------------|------|
| Single city center | 100 | ~$0.005 | ~5 sec |
| Full city (Athens) | 4,000+ | ~$0.01 | ~10 sec |
| Multiple cities | 10,000+ | ~$0.05 | ~1 min |
| Nationwide scan | 20,000+ | ~$0.10 | ~3 min |

The actor makes a single API call per location, so costs are minimal regardless of result count.

### Can I integrate?

Efood Scraper connects to the full Apify integration ecosystem:

- **Apify API** — Trigger runs programmatically, stream results in real-time
- **Webhooks** — Notify your systems when scraping completes
- **Google Sheets** — Auto-export restaurant data for analysis
- **Zapier / Make** — Build no-code automations with delivery data
- **Slack alerts** — Get notified about new restaurants or rating changes
- **BigQuery / Snowflake** — Stream to your data warehouse
- **Scheduled runs** — Set up daily monitoring with Apify Schedules
- **Direct download** — CSV, JSON, XML, or Excel export

### Can I use it as an API?

Use Efood Scraper as a Greek restaurant data API.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/efood-scraper").call(run_input={
    "location": "Thessaloniki",
    "cuisineFilter": "Souvlakia",
    "maxResults": 50,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    rating = item.get("rating", "N/A")
    fee = item.get("deliveryCost", 0)
    print(f"{item['name']} — {rating}/5, delivery: EUR {fee}")
```

#### JavaScript

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

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/efood-scraper").call({
  location: "Athens",
  searchQuery: "pizza",
  maxResults: 200,
});

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

items.forEach((item) => {
  const open = item.isOpen ? "OPEN" : "CLOSED";
  console.log(`${item.name} — ${item.rating}/5 [${open}] ${item.cuisines.join(", ")}`);
});
```

### FAQ

#### What cities does efood cover?

Efood operates in 100+ Greek cities. The scraper has built-in coordinates for 30+ major cities including Athens, Thessaloniki, Heraklion, Patras, Larissa, Volos, Ioannina, Chania, Rhodes, Corfu, Mykonos, and Santorini. For other locations, provide exact latitude/longitude coordinates.

#### Does efood only have restaurants?

No. Efood has expanded beyond food delivery to include supermarkets, pharmacies, pet shops, flower shops, and retail stores. The `vertical` field indicates the store type ("food", "grocery", etc.) and `cuisines` may include non-food categories like "Supermarket", "Pet shop", or "Pharmacy".

#### Why do some restaurants have 0 rating?

New restaurants on efood may not have accumulated enough ratings to display an average. The `reviewCount` field shows how many ratings exist. Restaurants with `rating: null` and `reviewCount: 0` are typically new additions to the platform.

#### Can I get menu items and individual dish prices?

The current version extracts restaurant-level data (delivery info, ratings, cuisines, hours). Menu/catalog data requires authentication on efood's API. If menu scraping is critical for your use case, let us know.

#### What is the difference between searchQuery and cuisineFilter?

`searchQuery` is a fuzzy keyword search that matches against restaurant name, cuisine, address, and chain name. `cuisineFilter` matches the exact cuisine category as defined by efood (e.g., "Pizza", "Burgers", "Souvlakia"). Use `cuisineFilter` when you know the exact category, and `searchQuery` for broader searches.

### Limitations

- **Menu data** — Individual menu items and dish prices require authentication and are not currently available. The actor focuses on restaurant-level data.
- **Location precision** — Results depend on the delivery radius from the given coordinates. Moving the point by a few kilometers may change which restaurants appear.
- **Real-time availability** — The `isOpen` field reflects the restaurant's status at scrape time. Availability changes throughout the day.
- **API rate limits** — Efood may rate-limit aggressive scraping. The actor uses Greek residential proxies by default for reliability.
- **Delivery Hero changes** — As part of Delivery Hero, efood's API may change without notice. We monitor and update the scraper to keep pace.

### Other European delivery scrapers

Build a complete view of European food delivery with companion scrapers from our catalog. Check [our Apify Store page](https://apify.com/studio-amba) for the full list of European scrapers.

### Your feedback

If you notice data quality issues, missing fields, or broken runs, let us know through the Apify Console or GitHub. We actively monitor and update this scraper to maintain reliability.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for restaurants by name or cuisine (e.g., 'pizza', 'souvlaki', 'McDonald's'). Works as a keyword filter on results for the given location.

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

City or area name to search in (e.g., 'Athens', 'Thessaloniki', 'Heraklion'). The scraper converts this to coordinates automatically. If you provide latitude/longitude below, this field is ignored.

## `latitude` (type: `number`):

Latitude of the delivery location (e.g., 37.9838 for Athens center). Overrides the 'location' field if provided.

## `longitude` (type: `number`):

Longitude of the delivery location (e.g., 23.7275 for Athens center). Overrides the 'location' field if provided.

## `cuisineFilter` (type: `string`):

Filter by cuisine type. Must match efood's cuisine categories exactly (e.g., 'Pizza', 'Burgers', 'Sushi', 'Souvlakia', 'Ελληνικη').

## `onlyOpen` (type: `boolean`):

If true, only return restaurants that are currently open for orders.

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

Maximum number of restaurants to return.

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

Proxy settings. Efood's API is generally accessible, but Greek residential proxies improve reliability for large runs.

## Actor input object example

```json
{
  "searchQuery": "souvlaki",
  "location": "Athens",
  "onlyOpen": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GR"
  }
}
```

# 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 = {
    "searchQuery": "souvlaki",
    "location": "Athens",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/efood-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 = {
    "searchQuery": "souvlaki",
    "location": "Athens",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/efood-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 '{
  "searchQuery": "souvlaki",
  "location": "Athens",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GR"
  }
}' |
apify call studio-amba/efood-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Efood Scraper - Greek Food Delivery Restaurants & Prices",
        "description": "Scrape restaurants, ratings, delivery info, cuisines, and prices from efood.gr — Greece's largest food delivery platform with 20,000+ stores.",
        "version": "0.1",
        "x-build-id": "tbU0gcHUh6ATgQHd5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~efood-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-efood-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/studio-amba~efood-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-efood-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/studio-amba~efood-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-efood-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for restaurants by name or cuisine (e.g., 'pizza', 'souvlaki', 'McDonald's'). Works as a keyword filter on results for the given location."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or area name to search in (e.g., 'Athens', 'Thessaloniki', 'Heraklion'). The scraper converts this to coordinates automatically. If you provide latitude/longitude below, this field is ignored.",
                        "default": "Athens"
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Latitude of the delivery location (e.g., 37.9838 for Athens center). Overrides the 'location' field if provided."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Longitude of the delivery location (e.g., 23.7275 for Athens center). Overrides the 'location' field if provided."
                    },
                    "cuisineFilter": {
                        "title": "Cuisine Filter",
                        "type": "string",
                        "description": "Filter by cuisine type. Must match efood's cuisine categories exactly (e.g., 'Pizza', 'Burgers', 'Sushi', 'Souvlakia', 'Ελληνικη')."
                    },
                    "onlyOpen": {
                        "title": "Only Open Restaurants",
                        "type": "boolean",
                        "description": "If true, only return restaurants that are currently open for orders.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of restaurants to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Efood's API is generally accessible, but Greek residential proxies improve reliability for large runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
