# Jobsite Jobs Search Scraper (`alexist/jobsite-jobs-search-scraper`) Actor

Scrape detailed job postings from Jobsite.co.uk, the UK's leading job board. Collect 32+ data fields including salary, location, company info, skills requirements, posting dates, and employment flags — perfect for job aggregators, recruiters, and labour market analysts.

- **URL**: https://apify.com/alexist/jobsite-jobs-search-scraper.md
- **Developed by:** [Alex](https://apify.com/alexist) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Jobsite.co.uk Jobs Scraper: Extract UK Job Listings at Scale
---

### What Is Jobsite.co.uk?

Jobsite.co.uk is one of the United Kingdom's largest online job boards, hosting hundreds of thousands of active vacancies across all industries and career levels. From entry-level positions to executive roles, Jobsite connects employers with job seekers nationwide. Extracting structured data from Jobsite listings manually is labour-intensive and error-prone — the **Jobsite Jobs Scraper** automates this process, delivering clean, standardised records ready for analysis or integration.

---

### Overview

The **Jobsite Jobs Scraper** extracts comprehensive job listings from Jobsite.co.uk search pages and detail pages, converting unstructured HTML into structured JSON records. It is designed for:

- **Job aggregators** building multi-source job feeds and comparison platforms
- **Recruiters and HR teams** monitoring market trends and competitor activity
- **Labour market researchers** studying UK employment demand and salary patterns
- **Career coaches** and advisors tracking industry-specific job growth
- **Data analysts** building dashboards on hiring volume, skills demand, and regional opportunities

Key strengths include configurable item limits, robust error handling with optional URL failure tolerance, and comprehensive output covering job details, company info, salary data, skills, and posting metadata.

---

### Input Format

The scraper accepts a straightforward JSON configuration:

```json
{
  "urls": [
    "https://www.jobsite.co.uk/jobs/admin",
    "https://www.jobsite.co.uk/jobs/marketing"
  ],
  "max_items_per_url": 200,
  "ignore_url_failures": true
}
````

#### Input Parameters

| Field | Type | Description | Example |
|---|---|---|---|
| `urls` | Array | URLs of Jobsite job listing pages to scrape. Supports category pages (e.g., `/jobs/admin`), search result pages, or filtered lists. | `["https://www.jobsite.co.uk/jobs/admin"]` |
| `max_items_per_url` | Integer | Maximum number of job listings to extract per URL. Useful for controlling data volume and scraper runtime. | `200` |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues running if some URLs fail; if `false`, stops on first error. Recommended `true` for bulk runs. | `true` |

> **Best practice:** Start with `max_items_per_url: 50-100` for testing, then increase for production runs. Use category or filtered URLs (not the homepage) to target specific job types.

***

### Output Format

#### Example Output Record

```json
{
  "id": 107707362,
  "title": "Admin",
  "labels": [],
  "url": "/tp-out?urlfragment=%2Fjob%2Fadmin%2Fjob-talent-job107707362%3FsearchCriteria%3DAdmin%26src%3Dsearch%26position%3D1%26source%3Djobsite%26WT.mc_id%3DA_PT_CrossBrand_Jobsite%26page%3D1",
  "company_id": 236510,
  "company_name": "Job&Talent",
  "company_url": "https://www.jobsite.co.uk/jobs/jobtalent?cmpId=236510&q=Job%26Talent&cmp=1",
  "company_logo_url": "https://www.totaljobs.com/CompanyLogos/68d5d7065d9743f687c6e38ba0d15a87.png",
  "date_posted": "2026-07-17T12:53:54.483Z",
  "location": "Roestock, Hatfield (AL10), AL10 9TQ",
  "is_anonymous": false,
  "salary": "Up to £14.45 per hour",
  "post_code": "AL10 9TQ",
  "partnership": {
    "is_partnership_job": false,
    "show_partnership_label": false,
    "is_backfilled": true,
    "source_site_friendly_name": "Totaljobs.com",
    "is_cross_posted": false
  },
  "unified_salary": null,
  "work_from_home": "",
  "meta_data": {
    "position_on_page": 1,
    "position_absolute": 1
  },
  "harmonised_id": "8a6e7ccf-5c65-481e-9792-fbce97285f43",
  "job_posting_sequence": 1,
  "period_posted_date": "2026-07-17T12:53:54.483Z",
  "publish_from_date": "2026-07-17T12:53:54.483Z",
  "publish_to_date": "2026-08-14T12:53:54.483Z",
  "has_future_posting": false,
  "fingerprint_count": 1,
  "section": "main",
  "top_labels": [
    {
      "label": "NEW",
      "type": "NEW"
    }
  ],
  "skills": [],
  "text_snippet": "At Job&Talent, we are recruiting for an Admin Transport to work with a leading company in the food production sector in Hatfield. This role is responsible for overseeing day-to-day transportation logistics and ensuring the smooth coordination of all transport activities. * 4 IN 4 OFF * Variable shifts from 36 to 48 hours per week * 14.45 GBP hourly * 6 months of experience in an administrative role * Proficiency in Excel * Good level of English * Positive attitude * Team player with strong communication skills * Punctual and reliable * Proactive attitude * Coordinate daily transportation logistics and schedules * Maintain accurate administrative records and documentation * Communicate effectively with transport teams and warehouse staff * Ensure the smooth and efficient flow of all transport activities * Opportunity to work in a fast-paced logistics environment",
  "cv_to_job_score": null,
  "is_highlighted": false,
  "is_sponsored": false,
  "travel_time": null,
  "unified_travel_time": null,
  "is_top_job": false,
  "is_traffic_from_partner": false,
  "from_url": "https://www.jobsite.co.uk/jobs/admin"
}
```

Each scraped job listing returns a rich record with 32+ fields, organised below by category:

#### Identification & URLs

| Field | Meaning |
|---|---|
| `id` | Unique Jobsite identifier for the listing |
| `url` | Direct link to the full job posting page |
| `harmonised_id` | Standardised ID for cross-platform job matching |
| `fingerprint_count` | Count of duplicate/similar listings detected |

#### Job Title & Classification

| Field | Meaning |
|---|---|
| `title` | Job title as displayed on the listing |
| `labels` | Categorical tags (e.g., "Full-time", "Permanent") |
| `top_labels` | Priority labels highlighted on search results |
| `section` | Jobsite section or category (e.g., IT, Finance) |
| `skills` | Array of required or preferred skills extracted from job description |

#### Company Information

| Field | Meaning |
|---|---|
| `company_name` | Employer name or hiring organisation |
| `company_id` | Unique Jobsite company identifier |
| `company_url` | Direct link to company's profile or website |
| `company_logo_url` | URL of company logo image |
| `is_anonymous` | `true` if the employer name is hidden from candidates |
| `partnership` | Flag indicating if the listing is from a recruitment partner or agency |
| `is_traffic_from_partner` | `true` if traffic to this listing originates from a partner integration |

#### Location & Salary

| Field | Meaning |
|---|---|
| `location` | Job location description (e.g., "London, Greater London") |
| `post_code` | UK postcode or postcode district of the role |
| `work_from_home` | Flexibility flag: `true` if remote or hybrid work is available |
| `travel_time` | Estimated commute time from a reference point (if calculated) |
| `unified_travel_time` | Standardised travel time across Jobsite's platform |
| `salary` | Salary information as displayed (may include ranges or "Competitive") |
| `unified_salary` | Normalised salary figure for comparison across listings |

#### Posting Timeline & Status

| Field | Meaning |
|---|---|
| `date_posted` | When the listing was originally posted |
| `period_posted_date` | Bucket/period of the posting date (e.g., "Today", "This week") |
| `publish_from_date` | Date when the listing became visible |
| `publish_to_date` | Date when the listing expires or was removed |
| `has_future_posting` | `true` if the posting has a scheduled future publish date |
| `job_posting_sequence` | Order of posting within a batch or campaign |

#### Visibility & Promotion

| Field | Meaning |
|---|---|
| `is_highlighted` | `true` if the listing has paid highlighting (e.g., bold, colour) |
| `is_sponsored` | `true` if the listing is a sponsored/featured placement |
| `is_top_job` | `true` if marked as a top or featured job on Jobsite |

#### Content & Matching

| Field | Meaning |
|---|---|
| `text_snippet` | Short text excerpt from the job description (preview text) |
| `meta_data` | Additional structured metadata (JSON object) |
| `cv_to_job_score` | Relevance score comparing job requirements to candidate CVs (if available) |

***

### How to Use

1. **Identify target URLs** — Browse Jobsite.co.uk and find job listing pages you want to scrape (e.g., category pages like `/jobs/admin`, or filtered search results).
2. **Prepare configuration** — Add URLs to the `urls` array. Set `max_items_per_url` based on how many listings you need (start with 50-100 for testing).
3. **Enable error tolerance** — Set `ignore_url_failures: true` to allow the scraper to skip problematic URLs without stopping the entire run.
4. **Run the scraper** — Start the actor and monitor progress in the log. The scraper will traverse listings and extract structured data.
5. **Export results** — Download the output as JSON, CSV, or Excel for analysis, import into databases, or feed into pipelines.

**Common tips:**

- Use category-specific URLs (e.g., `/jobs/marketing`) rather than broad search pages for cleaner, more targeted results.
- If scraping multiple pages, stagger runs to avoid overloading the server; set reasonable `max_items_per_url` limits.
- Check `salary` and `unified_salary` fields together — salary may vary in format, but `unified_salary` provides a numeric value for analysis.

***

### Use Cases & Business Value

- **Job market intelligence:** Track hiring volume, salary trends, and skills demand by industry and region
- **Competitive recruitment:** Monitor competitor job postings, benefits, and compensation packages
- **Job aggregation:** Build multi-source job boards combining Jobsite with other platforms
- **Labour research:** Analyse UK employment trends, emerging skills, and industry growth patterns
- **Recruiter tools:** Automate lead generation by identifying hiring companies and roles
- **Career analytics:** Study wage progression, role availability, and job market health

By automating data extraction, the Jobsite Jobs Scraper converts Jobsite's vast job database into actionable insights, eliminating hours of manual work and enabling data-driven hiring and market research decisions.

***

### Conclusion

The **Jobsite.co.uk Jobs Scraper** is a powerful tool for anyone needing large-scale, structured UK job data. With 32+ output fields covering job details, company information, salary, skills, and posting metadata, it delivers everything needed to build job aggregators, conduct labour market research, or power recruitment analytics. Start scraping today and unlock insights into the UK job market.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.jobsite.co.uk/jobs/admin"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 100
}
```

# 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 = {
    "urls": [
        "https://www.jobsite.co.uk/jobs/admin"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexist/jobsite-jobs-search-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 = {
    "urls": ["https://www.jobsite.co.uk/jobs/admin"],
    "ignore_url_failures": True,
    "max_items_per_url": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("alexist/jobsite-jobs-search-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 '{
  "urls": [
    "https://www.jobsite.co.uk/jobs/admin"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 100
}' |
apify call alexist/jobsite-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobsite Jobs Search Scraper",
        "description": "Scrape detailed job postings from Jobsite.co.uk, the UK's leading job board. Collect 32+ data fields including salary, location, company info, skills requirements, posting dates, and employment flags — perfect for job aggregators, recruiters, and labour market analysts.",
        "version": "0.0",
        "x-build-id": "BrGwkyl9ldrzAzwev"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alexist~jobsite-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alexist-jobsite-jobs-search-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/alexist~jobsite-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alexist-jobsite-jobs-search-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/alexist~jobsite-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alexist-jobsite-jobs-search-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": {
                    "urls": {
                        "title": "URLs of the Jobs list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
