# LinkedIn Jobs Scraper (`alex_demeniuk/linkedin-jobs-scraper`) Actor

Scrapes LinkedIn public jobs search results by query and location, enriches job detail pages, and stores structured job data in the dataset.

- **URL**: https://apify.com/alex\_demeniuk/linkedin-jobs-scraper.md
- **Developed by:** [Alex Demeniuk](https://apify.com/alex_demeniuk) (community)
- **Categories:** Social media, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## LinkedIn Jobs Guest Scraper

Scrape LinkedIn public jobs search results by keyword and location, open individual job detail pages, and save structured job data to the dataset.

This actor is designed for LinkedIn guest jobs pages and focuses on practical search-and-export workflows for market research, job tracking, and structured analysis.

### What this actor does

- Searches LinkedIn Jobs public guest results by keyword and location
- Works without requiring LinkedIn login or user authorization
- Supports optional geographic targeting via `geoId`
- Supports search filters such as distance, posting age, Easy Apply, and under-10-applicants
- Opens job detail pages and extracts structured metadata
- Saves results to the default dataset as JSON
- Imports job descriptions in Markdown-friendly form for downstream analysis
- Returns run summary metrics including jobs found, processed, and saved

### More relevant search results

LinkedIn Jobs search often returns many postings that are only loosely related to the search query. This happens because LinkedIn does not limit matching to the job title only — it can also match words found elsewhere in the posting, including the full vacancy text.

For example, a search for `Product manager` may return jobs whose actual title is not Product Manager at all, simply because the description mentions product management, product strategy, roadmaps, or related terms.

To improve result quality, the actor includes the `titleMustContainSearchWords` option.

When enabled, the actor saves only jobs whose title contains all meaningful words from the search query. This makes the results much more precise and is especially useful for broad searches like:

- `Product manager`
- `Data engineer`
- `Machine learning engineer`
- `Growth manager`

In practice, this is one of the most useful features of the actor because it dramatically reduces noisy results and makes the dataset far more useful for alerts, exports, trend tracking, and downstream analysis.

### Markdown descriptions for AI analysis

The actor extracts the vacancy description in Markdown-friendly form (`description_markdown`), which is much easier to reuse than raw HTML.

This is especially useful if you want to:

- analyze hiring trends with AI tools
- send postings into NotebookLM or other LLM workflows
- compare requirements, responsibilities, and skills across many roles
- build recurring weekly or monthly market snapshots
- prepare structured research inputs for downstream analysis

Markdown descriptions are cleaner, easier to read, and much better suited for AI-assisted analysis than scraped page HTML. If you still need the original raw markup, you can enable `includeDescriptionHtml`.

### Search result limit

LinkedIn guest jobs search has a practical limit of 1000 job cards. Beyond that point, additional results are not exposed in the guest search flow used by this actor.

Because of this platform limitation:

- `maxJobs` cannot be greater than 1000
- even very broad searches may stop at the first 1000 available job cards
- narrowing the query with better keywords, location filters, or the title filter often produces better data than simply trying to fetch more results

### Input

#### Main fields

- `searchQuery` — Job search phrase used on LinkedIn Jobs. The actor wraps the query in quotes to improve precision and reduce loosely related matches.
- `location` — Human-readable location string used in LinkedIn search.
- `geoId` — Optional LinkedIn region ID for more stable location targeting.
- `titleMustContainSearchWords` — If enabled, only saves jobs whose title contains all meaningful search words.
- `radiusMiles` — Optional search radius in miles.
- `postedWithinDays` — Optional LinkedIn recency filter.
- `under10Applicants` — If enabled, keeps only jobs marked as under 10 applicants.
- `easyApply` — If enabled, keeps only Easy Apply jobs.
- `maxJobs` — Maximum number of job cards to process, including skipped, filtered, and saved jobs.
- `includeDescriptionHtml` — If enabled, includes raw job description HTML in the output.
- `proxyConfiguration` — Optional proxy settings.

#### Example input

```json
{
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "searchQuery": "Product manager",
  "location": "San Francisco, Bay Area",
  "titleMustContainSearchWords": true,
  "radiusMiles": 0,
  "postedWithinDays": 1,
  "under10Applicants": false,
  "easyApply": false,
  "maxJobs": 1000,
  "includeDescriptionHtml": false
}
````

### Output

The actor stores one item per saved job posting in the dataset.

Typical dataset fields include:

- `job_id`
- `title`
- `company`
- `location`
- `job_url`
- `listed_at`
- `listed_at_iso`
- `applicants_text`
- `under_10_applicants`
- `search_query`
- `search_location`
- `search_geo_id`
- `search_radius_miles`
- `offset`
- `position`
- `description_markdown`
- `description_html` (optional, if enabled)
- `seniority_level`
- `employment_type`
- `job_function`
- `industries`
- `job_criteria_text`
- `company_url`
- `salary_text`
- `salary_min`
- `salary_max`
- `salary_currency`
- `salary_period`
- `recruiter_name`
- `recruiter_title`
- `recruiter_profile_url`

#### Example output item

```json
{
  "job_id": "4262502911",
  "title": "Senior Product Manager",
  "company": "Example Company",
  "location": "San Francisco Bay Area",
  "job_url": "https://www.linkedin.com/jobs/view/4262502911/",
  "listed_at": "3 days ago",
  "listed_at_iso": "2026-07-20T00:00:00+00:00",
  "applicants_text": "Over 100 applicants",
  "under_10_applicants": false,
  "search_query": "Product manager",
  "search_location": "San Francisco, Bay Area",
  "search_geo_id": "90000084",
  "search_radius_miles": 0,
  "offset": 0,
  "position": 1,
  "description_markdown": "## About the role\n\nThis is an example normalized job description.",
  "description_html": null,
  "seniority_level": "Mid-Senior level",
  "employment_type": "Full-time",
  "job_function": "Product Management",
  "industries": "Software Development",
  "job_criteria_text": "Mid-Senior level · Full-time · Product Management · Software Development",
  "company_url": "https://www.linkedin.com/company/example-company/",
  "salary_text": "$180,000 - $220,000 per year",
  "salary_min": 180000,
  "salary_max": 220000,
  "salary_currency": "USD",
  "salary_period": "year",
  "recruiter_name": "Jane Recruiter",
  "recruiter_title": "Senior Talent Partner",
  "recruiter_profile_url": "https://www.linkedin.com/in/jane-recruiter/"
}
```

### Run output

The actor also returns run-level summary fields:

- `results` — API URL for the dataset items
- `jobsFound` — Number of jobs found by the actor logic
- `jobsProcessed` — Number of processed job cards
- `jobsSaved` — Number of dataset items actually saved

### Notes and limitations

- This actor works with LinkedIn public jobs guest pages, not authenticated browsing.
- No LinkedIn login or user authorization is required.
- LinkedIn search results can shift between runs, so offsets and ordering are not guaranteed to be stable.
- Some fields are only available on certain postings and may be missing.
- Salary data is sparse and inconsistent across employers.
- Recruiter and company metadata may vary by posting quality.
- `maxJobs` limits processed job cards, not just saved dataset items.
- The actor intentionally avoids relying on unstable fields unless they are present on the page.
- Duplicate-looking postings can still appear across agencies, locations, or relisted jobs.
- The guest jobs flow used here exposes at most 1000 job cards for a given search.

### Use cases

- Job search monitoring by keyword, location, and recency
- Research workflows for studying vacancy requirements, responsibilities, and hiring patterns
- Salary and skill analysis across roles and employers
- Building datasets for downstream LLM summarization, reporting, and trend tracking

# Actor input Schema

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

Optional Apify Proxy configuration. If not set or unavailable, the actor will run without a proxy.

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

Job search phrase used on LinkedIn Jobs. The actor wraps the query in quotes to improve result precision and return jobs closer to the exact phrase.

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

Location string for LinkedIn Jobs search, for example city, state, or country. Kept for backward compatibility and still sent to LinkedIn even when geoId is provided.

## `geoId` (type: `string`):

Optional LinkedIn geographic region ID for more stable location targeting. Example: 90000070.

## `titleMustContainSearchWords` (type: `boolean`):

If enabled, save only jobs whose title contains all meaningful words from the search query.

## `radiusMiles` (type: `integer`):

Optional distance radius in miles. Allowed values are from 0 to 100 with step 1.

## `postedWithinDays` (type: `integer`):

Optional filter for jobs posted within the last N days.

## `under10Applicants` (type: `boolean`):

If enabled, keep only jobs marked as having fewer than 10 applicants.

## `easyApply` (type: `boolean`):

If enabled, keep only jobs matching the Easy Apply filter.

## `maxJobs` (type: `integer`):

Maximum number of job cards to process, including skipped, filtered, and saved jobs.

## `includeDescriptionHtml` (type: `boolean`):

If true, raw LinkedIn job description HTML will be included in output. Default is false.

## Actor input object example

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "searchQuery": "Product manager",
  "location": "San Francisco, Bay Area",
  "titleMustContainSearchWords": true,
  "radiusMiles": 0,
  "postedWithinDays": 7,
  "under10Applicants": false,
  "easyApply": false,
  "maxJobs": 10,
  "includeDescriptionHtml": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `jobsFound` (type: `string`):

No description

## `jobsProcessed` (type: `string`):

No description

## `jobsSaved` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("alex_demeniuk/linkedin-jobs-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("alex_demeniuk/linkedin-jobs-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 '{}' |
apify call alex_demeniuk/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper",
        "description": "Scrapes LinkedIn public jobs search results by query and location, enriches job detail pages, and stores structured job data in the dataset.",
        "version": "0.1",
        "x-build-id": "DaVeyxwuWeIulk0Nt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alex_demeniuk~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alex_demeniuk-linkedin-jobs-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/alex_demeniuk~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alex_demeniuk-linkedin-jobs-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/alex_demeniuk~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alex_demeniuk-linkedin-jobs-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": [
                    "searchQuery",
                    "location"
                ],
                "properties": {
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration. If not set or unavailable, the actor will run without a proxy.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Job search phrase used on LinkedIn Jobs. The actor wraps the query in quotes to improve result precision and return jobs closer to the exact phrase.",
                        "default": "Product manager"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location string for LinkedIn Jobs search, for example city, state, or country. Kept for backward compatibility and still sent to LinkedIn even when geoId is provided.",
                        "default": "San Francisco, Bay Area"
                    },
                    "geoId": {
                        "title": "LinkedIn geoId",
                        "type": "string",
                        "description": "Optional LinkedIn geographic region ID for more stable location targeting. Example: 90000070."
                    },
                    "titleMustContainSearchWords": {
                        "title": "Title must contain search words",
                        "type": "boolean",
                        "description": "If enabled, save only jobs whose title contains all meaningful words from the search query.",
                        "default": true
                    },
                    "radiusMiles": {
                        "title": "Search radius in miles",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Optional distance radius in miles. Allowed values are from 0 to 100 with step 1.",
                        "default": 0
                    },
                    "postedWithinDays": {
                        "title": "Posted within days",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Optional filter for jobs posted within the last N days.",
                        "default": 7
                    },
                    "under10Applicants": {
                        "title": "Under 10 applicants only",
                        "type": "boolean",
                        "description": "If enabled, keep only jobs marked as having fewer than 10 applicants.",
                        "default": false
                    },
                    "easyApply": {
                        "title": "Easy Apply only",
                        "type": "boolean",
                        "description": "If enabled, keep only jobs matching the Easy Apply filter.",
                        "default": false
                    },
                    "maxJobs": {
                        "title": "Maximum number of jobs to process",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job cards to process, including skipped, filtered, and saved jobs.",
                        "default": 10
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "If true, raw LinkedIn job description HTML will be included in output. Default is false.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```