# Uber Eats Reviews · Reputation Monitoring (`corent1robert/uber-eats-reviews-scraper`) Actor

Monitor Uber Eats store ratings and latest public customer comments. Paste store URLs — export aggregate scores plus a recent review sample (often 1–3 in France, not full history). Built for reputation teams and agencies.

- **URL**: https://apify.com/corent1robert/uber-eats-reviews-scraper.md
- **Developed by:** [Corentin Robert](https://apify.com/corent1robert) (community)
- **Categories:** Social media, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.25 / 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.

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

## Uber Eats Reviews Scraper

**Reputation monitoring for Uber Eats** — track store ratings and the latest public customer comments your locations (or competitors) show on Uber Eats.

Paste store URLs. Export **aggregate scores** plus a **recent review sample** in one table — ready for spreadsheets, alerts, or BI.

**No login. No API key. No Uber Eats account.**

---

### What this Actor is for

| Use case | What you monitor | What you get |
|----------|------------------|--------------|
| **Reputation management** | Score drift + fresh negative/positive comments | `aggregateRatingValue`, `aggregateReviewCount`, latest review texts |
| **Local / franchise ops** | Each location on Uber Eats | One row per public comment · store context on every row |
| **Agency client reporting** | Client restaurants vs competitors | Paste URL lists · schedule recurring runs |
| **Quality / CX benchmarking** | Voice-of-customer snapshot + headline rating | JSON/CSV export · dedupe with `reviewUuid` |

### What this Actor is **not**

- **Not** a full review history export — Uber Eats does not expose every past comment on the public store page.
- **Not** a per-review star rating tool — individual review stars are usually missing; use **`aggregateRatingValue`** for score tracking.
- **Not** a replacement for Uber Eats merchant dashboards — this reads **public** store pages only.

---

### How many reviews per store?

Uber Eats embeds a **small recent sample** in each store page — we export **all of it**, not a subset.

| Market (observed) | Typical text reviews per run | Total ratings shown by Uber |
|-------------------|------------------------------|-----------------------------|
| **France** | Often **1–3** comments | Often **500–4,000+** (aggregate only) |
| **United States** | Up to **~14** on some stores | Can be **800+** (aggregate only) |

Example: a French Burger King with **4,000+** total ratings may yield **3** review rows — that is expected, not a scraper bug.

Every row still carries **`aggregateRatingValue`** and **`aggregateReviewCount`** so you can monitor the headline score even when few comments are public.

---

### What you get

| Field | Description |
|-------|-------------|
| `reviewText` | Verbatim customer comment |
| `eaterName` | Display name (e.g. `Valerie S.`) |
| `createdAt` | Review timestamp when available (ISO 8601) |
| `rating` | Per-review star score — **often null** (store average only) |
| `storeId` | Stable store UUID from the URL |
| `storeName` | Restaurant name |
| `aggregateRatingValue` | Store average rating |
| `aggregateReviewCount` | Total ratings count on Uber Eats |
| `reviewUuid` | Stable review identifier for deduplication |
| `storeUrl` | Source store page |

#### Typical fill rates (reference export)

| Field | Coverage | Notes |
|-------|----------|-------|
| `reviewText`, `eaterName`, `createdAt` | High on stores with public comments | SSR sample only |
| `aggregateRatingValue`, `aggregateReviewCount` | ~100% on valid store pages | From structured data |
| `rating` (per review) | ~0% | Uber Eats usually omits per-review stars |
| Stores with zero text reviews | Possible | Logged, no dataset row (no review charge) |

---

### Important limitations

- **Reputation snapshot, not an archive** — only the **recent public sample** Uber Eats puts on the store page (see table above).
- **`aggregateReviewCount` ≫ row count** — total ratings can be in the thousands while you export a handful of recent comments.
- **France often means 1–3 rows** — plan dashboards and billing accordingly; US stores may return more.
- **Per-review stars** are usually `null`; monitor **`aggregateRatingValue`** instead.
- Data reflects what Uber Eats shows **publicly** at scrape time — no logged-in or merchant-only views.

---

### Quick start

1. Open an Uber Eats **store page** in your browser.
2. Copy the URL (contains `/store/restaurant-slug/store-id`).
3. Paste into **Store URL(s)** in the Actor input.
4. Click **Start** — rows appear in the dataset (one row per review).

Need store URLs at scale? Use the **[Uber Eats Pro Scraper](https://apify.com/corent1robert/uber-eats-pro-scraper)** to discover restaurants by city, then paste URLs here. For **menus and prices** on the same stores, see the **[Uber Eats Menu Scraper](https://apify.com/corent1robert/uber-eats-menu-scraper)**.

---

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `storeUrls` | Array | Wamys Annecy example | Uber Eats store page URLs |
| `maxStores` | Integer | `10` | Cap stores processed (`0` = no cap) |
| `maxReviewsPerStore` | Integer | `0` | Cap reviews per store (`0` = full SSR sample) |

#### API-only parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `verboseLogs` | Boolean | `false` | Technical extraction details in run log |
| `proxyConfiguration` | Object | none | Apify proxy settings if pages block datacenter egress |

#### Input example

```json
{
  "storeUrls": [
    { "url": "https://www.ubereats.com/fr/store/wamys/oCwUa_VfWJ2wlyiU6xz3Hg" },
    { "url": "https://www.ubereats.com/fr/store/burger-king-epagny/ZOjYdsqgQcqPQ5q40GJoXQ" }
  ],
  "maxStores": 0,
  "maxReviewsPerStore": 0
}
````

***

### Output example

```json
{
  "storeUrl": "https://www.ubereats.com/fr/store/wamys/oCwUa_VfWJ2wlyiU6xz3Hg",
  "storeId": "oCwUa_VfWJ2wlyiU6xz3Hg",
  "storeName": "Wamy's",
  "aggregateRatingValue": 4.3,
  "aggregateReviewCount": 1000,
  "reviewUuid": "cc0aa07e-f83b-4e9b-a7e8-3c4f5b846378",
  "eaterName": "Valerie S.",
  "reviewText": "Super bon ! Contente de mes crevettes",
  "reviewTextShort": "Super bon ! Contente de mes crevettes",
  "createdAt": "2025-01-28T00:00:00Z",
  "rating": null,
  "scrapedAt": "2026-06-07T12:00:00.000Z"
}
```

***

### How it works

1. Fetches each public store page over HTTP (Chrome-like headers for full SSR).
2. Reads **store rating + total ratings count** from structured data (your reputation KPIs).
3. Parses the embedded **`storeReviews`** sample — the same recent comments visible on the page.
4. Pushes **one dataset row per review**, with store aggregates duplicated on each row for easy filtering.

***

### How much does it cost to scrape Uber Eats reviews?

Pay-per-event pricing (HTTP-only — compute stays low):

| Scenario | Approx. cost |
|----------|-------------|
| ~10 reviews (first test) | ~$0.06 |
| 500 reviews | ~$0.55 |
| 5,000 reviews | ~$5.05 |

Includes **$0.05 run start** + **$0.001 per review row**. Stores with **zero** text reviews in the SSR sample are not billed as reviews.

***

### Is it legal to scrape Uber Eats?

This Actor only accesses data that Uber Eats makes publicly available on store pages. As with any dataset containing personal information (customer names, comments), ensure your use complies with GDPR and applicable regulations.

***

### Local development

```bash
cd uber-eats-reviews-scraper
npm install
npm test
npm run sync-input
apify run
```

- **`.actor/INPUT.json`** mirrors Console Try prefill and is copied to `storage/.../INPUT.json` by `npm run sync-input`.
- Root **`input.json`** can hold heavier presets; merged at runtime when not on Apify Cloud (KV input wins on key conflicts).
- Local dataset: `storage/datasets/default/`

***

### Also available

- **[Uber Eats Pro Scraper](https://apify.com/corent1robert/uber-eats-pro-scraper)** — discover restaurant store URLs by city or territory, with phones, addresses, and company IDs for outbound teams.
- **[Uber Eats Menu Scraper](https://apify.com/corent1robert/uber-eats-menu-scraper)** — export full menus (items, sections, prices) from the same store URLs — pricing benchmarks and category research.

***

### Support

Contact <corentin@outreacher.fr> for custom scrapers or tailored automation.

# Actor input Schema

## `storeUrls` (type: `array`):

Each URL should look like `https://www.ubereats.com/fr/store/restaurant-name/store-id`. Get URLs from Uber Eats or from the Uber Eats Pro Scraper.

## `maxStores` (type: `integer`):

Stop after this many store URLs. **0** = process every URL you pasted.

## `maxReviewsPerStore` (type: `integer`):

Cap reviews exported per store. **0** = export the full public sample Uber Eats shows (often **1–3** in France, up to **~14** in some US stores — not the total ratings count).

## Actor input object example

```json
{
  "storeUrls": [
    {
      "url": "https://www.ubereats.com/fr/store/wamys/oCwUa_VfWJ2wlyiU6xz3Hg"
    },
    {
      "url": "https://www.ubereats.com/fr/store/burger-king-epagny/ZOjYdsqgQcqPQ5q40GJoXQ"
    },
    {
      "url": "https://www.ubereats.com/fr/store/mcdonalds-epagny/b4043WTlR_iSrNu0-Y2DYQ"
    }
  ],
  "maxStores": 10,
  "maxReviewsPerStore": 0
}
```

# Actor output Schema

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

Slim table view for quick review in Apify Console.

## `full` (type: `string`):

All review fields including full text.

## `allItems` (type: `string`):

No description

## `runLog` (type: `string`):

Human-readable milestone log from the run.

# 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 = {
    "storeUrls": [
        {
            "url": "https://www.ubereats.com/fr/store/wamys/oCwUa_VfWJ2wlyiU6xz3Hg"
        },
        {
            "url": "https://www.ubereats.com/fr/store/burger-king-epagny/ZOjYdsqgQcqPQ5q40GJoXQ"
        },
        {
            "url": "https://www.ubereats.com/fr/store/mcdonalds-epagny/b4043WTlR_iSrNu0-Y2DYQ"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("corent1robert/uber-eats-reviews-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 = { "storeUrls": [
        { "url": "https://www.ubereats.com/fr/store/wamys/oCwUa_VfWJ2wlyiU6xz3Hg" },
        { "url": "https://www.ubereats.com/fr/store/burger-king-epagny/ZOjYdsqgQcqPQ5q40GJoXQ" },
        { "url": "https://www.ubereats.com/fr/store/mcdonalds-epagny/b4043WTlR_iSrNu0-Y2DYQ" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("corent1robert/uber-eats-reviews-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 '{
  "storeUrls": [
    {
      "url": "https://www.ubereats.com/fr/store/wamys/oCwUa_VfWJ2wlyiU6xz3Hg"
    },
    {
      "url": "https://www.ubereats.com/fr/store/burger-king-epagny/ZOjYdsqgQcqPQ5q40GJoXQ"
    },
    {
      "url": "https://www.ubereats.com/fr/store/mcdonalds-epagny/b4043WTlR_iSrNu0-Y2DYQ"
    }
  ]
}' |
apify call corent1robert/uber-eats-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Uber Eats Reviews · Reputation Monitoring",
        "description": "Monitor Uber Eats store ratings and latest public customer comments. Paste store URLs — export aggregate scores plus a recent review sample (often 1–3 in France, not full history). Built for reputation teams and agencies.",
        "version": "1.2",
        "x-build-id": "HKadukRtH9meBlUFm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/corent1robert~uber-eats-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-corent1robert-uber-eats-reviews-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/corent1robert~uber-eats-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-corent1robert-uber-eats-reviews-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/corent1robert~uber-eats-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-corent1robert-uber-eats-reviews-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": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Store URL(s)",
                        "type": "array",
                        "description": "Each URL should look like `https://www.ubereats.com/fr/store/restaurant-name/store-id`. Get URLs from Uber Eats or from the Uber Eats Pro Scraper.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxStores": {
                        "title": "Max stores",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many store URLs. **0** = process every URL you pasted.",
                        "default": 10
                    },
                    "maxReviewsPerStore": {
                        "title": "Max reviews per store",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap reviews exported per store. **0** = export the full public sample Uber Eats shows (often **1–3** in France, up to **~14** in some US stores — not the total ratings count).",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
