# TrustMate.io Reviews Scraper (`memo23/trustmate-reviews-scraper`) Actor

Turn any TrustMate.io company profile into structured review data — rating, full text, author, date, company replies, verified flag and translations, one row per review. Paginates the full review history, not just page one. Works with Polish and English profiles. JSON, CSV or Excel.

- **URL**: https://apify.com/memo23/trustmate-reviews-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 review scrapeds

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

## TrustMate.io Reviews Scraper 🟢

Extract company reviews from **TrustMate.io** — the review platform leading in Poland and expanding across the EU. Get the full review text, star rating, author, date, the **company's reply**, verified flag, helpful votes and multi-language translations, plus company-level aggregate stats. Paste a company review URL (or just a domain) and export to JSON, CSV or Excel.

![How TrustMate Reviews Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-trustmate.png)

### Why use this scraper?

- ⚡ **Full reviews, not just the first page.** Paginates the entire review history for a company, not the ~28 most-recent reviews shown on the page.
- 🟢 **Richer than the page.** Pulls from TrustMate's public JSON API, so each review includes fields the HTML doesn't surface — the company's reply, helpful/unhelpful votes, import source and machine translations.
- 🗣️ **Company replies included.** See how each business responded to its reviewers — gold for reputation and competitor research.
- 🌍 **PL + EN, any company.** Works with `trustmate.io/opinie/{slug}` (Polish) and `en.trustmate.io/reviews/{slug}` (English), or just a bare domain/slug.
- 🧾 **One clean row per review** with company context attached — ready for analysis in seconds.
- 💸 **Pay per result.** Transparent per-review pricing; cap any run with `maxItems`.

### Overview

TrustMate.io is a review-collection platform used by thousands of online shops and service businesses, with a strong base in Poland and growing coverage across Italy and the wider EU. Each company has a public profile page listing customer reviews, an average grade and aggregate counts.

This actor turns any TrustMate company profile into structured data. Point it at one or many companies and it returns every service review with the reviewer, rating, body text, date, the business's reply, verification status and translations — plus the company's name, website, category and aggregate rating on every row.

### Supported inputs

| You paste… | Example | What you get |
|---|---|---|
| A company review URL (PL) | `https://trustmate.io/opinie/trustmate-io` | All reviews for that company |
| A company review URL (EN) | `https://en.trustmate.io/reviews/trustmate-io` | Same company, same data |
| A bare domain or slug | `ogrodniczy.com` or `trustmate-io` | Auto-resolved to its review feed |

Mix as many companies as you like in a single run.

### Use cases

- **Reputation monitoring** — track new reviews, ratings and replies for your own brand on TrustMate.
- **Competitor analysis** — pull a rival's full review history and read how they handle complaints.
- **Voice-of-customer & CX** — mine review text (and translations) for recurring praise and pain points.
- **Lead and market research** — assess merchants by review volume, rating and category.
- **Data enrichment** — append review counts and average ratings to a list of companies/domains.
- **Trust & safety / due diligence** — review-history checks on a vendor or partner.

### How it works

1. **Input** — paste TrustMate company review URLs (PL `/opinie/` or EN `/reviews/`) or bare domains/slugs.
2. **Resolve** — each slug is resolved via the public account API to the company's numeric id + aggregate stats.
3. **Paginate** — the review API is walked with offset pagination until every review is collected (or `maxItems` is reached).
4. **Map** — each review is flattened with its company context (name, website, category, average rating).
5. **Output** — one row per review to the Apify dataset, exportable as JSON, CSV or Excel.

TrustMate has no anti-bot protection, so the actor runs fast and reliably on the default Apify proxy (residential proxies are not required).

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `["https://trustmate.io/opinie/trustmate-io"]` | Company review URLs or bare domains/slugs. |
| `companySlugs` | array | – | Optional convenience list of bare slugs/domains. |
| `maxItems` | integer | `1000` | Hard cap on total reviews collected across all companies. |
| `maxConcurrency` | integer | `5` | How many companies to fetch in parallel. |
| `proxy` | object | Apify Proxy | Proxy settings. Default is fine — set Use Apify Proxy off to run direct. |

#### Example input

```json
{
  "startUrls": [
    "https://trustmate.io/opinie/trustmate-io",
    "ogrodniczy.com"
  ],
  "maxItems": 500,
  "maxConcurrency": 5
}
````

### Output

One row per review. Example (trimmed):

```json
{
  "platform": "trustmate",
  "reviewId": "19168801",
  "reviewPublicId": "2ba1e87e-271d-4364-a279-802fe3811d7f",
  "rating": 5,
  "reviewBody": "Mega intuicyjny interfejs użytkownika, dzięki czemu korzystanie jest proste...",
  "authorName": "ogrodniczy.com",
  "reviewDate": "2026-05-13T06:31:00+00:00",
  "language": "pl",
  "verified": true,
  "companyReply": "Bardzo dziękujemy za opinię, staramy się jak możemy...",
  "companyReplyDate": "2026-05-13T07:43:19+00:00",
  "helpfulCount": 1,
  "unhelpfulCount": 1,
  "translations": [{ "language": "en", "body": "Mega intuitive user interface..." }],
  "companyName": "TrustMate.io",
  "companySlug": "trustmate-io",
  "companyWebsite": "https://trustmate.io",
  "companyCategory": "Opinie o firmach i produktach",
  "companyRatingAvg": 4.89,
  "companyServiceReviewCount": 773,
  "companyCombinedReviewCount": 1435,
  "sourceUrl": "https://trustmate.io/opinie/trustmate-io",
  "scrapedAt": "2026-06-26T09:28:11.300Z"
}
```

#### Key output fields

| Field | Description |
|---|---|
| `rating` | Star rating, 1–5 (`grade`). |
| `reviewBody` | Full review text. |
| `authorName` | Reviewer name (customer name, or the reviewing business's domain for B2B). |
| `reviewDate` / `reviewUpdatedAt` | When the review was published / last edited (ISO 8601). |
| `language` | Original review language. |
| `verified` | Whether TrustMate marks the review as verified. |
| `companyReply` / `companyReplyDate` | The business's public reply, if any. |
| `helpfulCount` / `unhelpfulCount` | Helpful-vote tallies. |
| `translations` | Machine translations of the review body (array of `{language, body}`). |
| `pinned`, `imported`, `importSource` | Review metadata flags. |
| `companyName`, `companySlug`, `companyWebsite`, `companyCategory` | Company context on every row. |
| `companyRatingAvg` | Company's average grade over service reviews. |
| `companyServiceReviewCount` | Number of service reviews available for this company (what this actor paginates). |
| `companyCombinedReviewCount` | Headline total shown on the profile (service + product reviews). |

### FAQ

**Does it scrape all reviews or just the first page?**
All of them. The actor paginates the company's full service-review history via the JSON API, not just the reviews rendered on the first page.

**What's the difference between `companyServiceReviewCount` and `companyCombinedReviewCount`?**
`companyServiceReviewCount` is the number of company/service reviews this actor returns. `companyCombinedReviewCount` is the larger headline figure on the profile, which also includes product reviews. Product reviews are a separate feed — tell us if you'd like them added.

**Does it include the company's replies?**
Yes — `companyReply` and `companyReplyDate` capture the business's public response to each review where one exists.

**Polish or English?**
Both. PL `/opinie/{slug}` and EN `/reviews/{slug}` URLs resolve to the same company. Review bodies are returned in their original language, with `translations` where TrustMate provides them.

**Do I need a residential proxy?**
No. TrustMate has no anti-bot protection — the default Apify Proxy is plenty, and you can even run direct.

**How is it billed?**
Pay-per-result: you're charged per review row returned. Use `maxItems` to cap any run.

### Support

Found a bug or need an extra field (e.g. product reviews, rating breakdown)? Open an issue on the actor's **Issues** tab and we'll take a look.

### Additional services

Need a custom scraper, a recurring schedule, or the data pushed to your database/webhook? We build and maintain review, directory and e-commerce scrapers across many platforms — get in touch via the Issues tab.

### Explore more scrapers

If you collect reviews, you may also want coverage on the larger platforms — Trustpilot, Google, Capterra and more. Check the publisher's other actors on the Apify Store.

### ⚠️ Disclaimer

This actor collects only **publicly available** information from TrustMate.io — the same data any visitor can see without logging in. It does not bypass authentication, access private data, or collect anything behind a login. Use the data in compliance with TrustMate's Terms of Service, applicable laws (including GDPR and other data-protection regulations), and the rights of data subjects. You are responsible for how you use the scraped data; review text is the intellectual property of its authors and platform. This actor is not affiliated with, endorsed by, or sponsored by TrustMate.io.

### SEO keywords

TrustMate scraper, TrustMate.io reviews scraper, TrustMate reviews API, scrape TrustMate reviews, TrustMate opinie scraper, Polish reviews scraper, company reviews scraper, e-commerce reviews scraper, online review data, reputation monitoring, competitor review analysis, voice of customer data, review export CSV JSON, EU reviews scraper, Trustpilot alternative reviews.

# Actor input Schema

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

TrustMate company review URLs (e.g. https://trustmate.io/opinie/trustmate-io) or bare slugs/domains (e.g. trustmate.io, ogrodniczy.com). Mix freely — each is resolved to the company's review feed.

## `companySlugs` (type: `array`):

Convenience list of bare company slugs or domains (e.g. trustmate-io, ogrodniczy.com). Resolved to review URLs the same way as Start URLs.

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

Hard cap on the total number of review rows collected across all companies. Use it to control billing.

## `maxConcurrency` (type: `integer`):

How many companies to fetch in parallel. Review pages within one company are fetched sequentially.

## `proxy` (type: `object`):

TrustMate has no anti-bot protection, so the default Apify proxy is sufficient — residential proxies are not required. Set 'Use Apify Proxy' off to run direct.

## Actor input object example

```json
{
  "startUrls": [
    "https://trustmate.io/opinie/trustmate-io"
  ],
  "maxItems": 1000,
  "maxConcurrency": 5,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "https://trustmate.io/opinie/trustmate-io"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/trustmate-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 = {
    "startUrls": ["https://trustmate.io/opinie/trustmate-io"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/trustmate-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 '{
  "startUrls": [
    "https://trustmate.io/opinie/trustmate-io"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/trustmate-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustMate.io Reviews Scraper",
        "description": "Turn any TrustMate.io company profile into structured review data — rating, full text, author, date, company replies, verified flag and translations, one row per review. Paginates the full review history, not just page one. Works with Polish and English profiles. JSON, CSV or Excel.",
        "version": "0.0",
        "x-build-id": "PJozbx3V5O6q5s8KX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~trustmate-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-trustmate-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/memo23~trustmate-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-trustmate-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/memo23~trustmate-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-trustmate-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",
                "properties": {
                    "startUrls": {
                        "title": "Company review URLs (or slugs/domains)",
                        "type": "array",
                        "description": "TrustMate company review URLs (e.g. https://trustmate.io/opinie/trustmate-io) or bare slugs/domains (e.g. trustmate.io, ogrodniczy.com). Mix freely — each is resolved to the company's review feed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySlugs": {
                        "title": "Company slugs / domains (optional)",
                        "type": "array",
                        "description": "Convenience list of bare company slugs or domains (e.g. trustmate-io, ogrodniczy.com). Resolved to review URLs the same way as Start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum reviews to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of review rows collected across all companies. Use it to control billing.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency (companies in parallel)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many companies to fetch in parallel. Review pages within one company are fetched sequentially.",
                        "default": 5
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "TrustMate has no anti-bot protection, so the default Apify proxy is sufficient — residential proxies are not required. Set 'Use Apify Proxy' off to run direct.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```