# EdJoin Jobs Scraper: Educator & School District Listings (`getascraper/edjoin-scraper`) Actor

Extract EdJoin teaching, administrative, and classified K-12 school job listings. Collect contact emails, salary ranges, deadlines, and requirements. Direct fast JSON API crawling with JSON-LD detail mapping. Best value at an affordable price.

- **URL**: https://apify.com/getascraper/edjoin-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 jobs

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

## EdJoin Scraper: K-12 Teaching, Certificated and Classified Job Listings

Get instant, structured access to K-12 education jobs across US school districts. Extract direct HR contact emails, salary ranges, deadlines, locations, and requirements in bulk with zero visual DOM fragility.

### What does EdJoin Scraper do?

The **EdJoin Scraper** is a fast web crawling tool that extracts complete education vacancy listings from **EdJoin** (edjoin.org), the largest job board for public and private school districts in the United States. 

It pulls data from two main sources:
1. **Listing Search API**: Queries EdJoin's backend JSON search index directly to discover postings based on keywords and locations. This allows high-concurrency, fast walks of thousands of records with zero web browser overhead.
2. **Detail Page JSON-LD Parsing**: Loads the detail page of each discovered vacancy to extract structured Schema.org `JobPosting` JSON-LD blocks containing direct school contact emails, full credential requirements, and required skills.

With Apify, you can run this scraper via a simple REST API, schedule it to run daily or weekly to monitor new postings, and automatically integrate the results with Google Sheets, Airtable, Make, or webhooks.

### Why use EdJoin Scraper?

- **Find High-Intent HR & Recruiting Leads**: For staffing agencies, B2B marketers, and recruiting firms looking to discover direct contact emails of hiring managers and school district coordinators.
- **Keep Your Education Career Board Updated**: Keep your own education career board up-to-date with complete vacancy metadata, direct links, salary structures, and expiration dates.
- **Benchmark Teacher Salaries & Benefits**: Analyze teacher salaries, work schedules, required certifications, and posting volumes across districts, counties, and states.
- **Set Up Daily Automated Alerts**: Schedule the scraper to run daily to detect fresh vacancies matching your criteria (e.g. "Special Education Teacher" in "Los Angeles") and send instant notifications to your teams.

### How to use EdJoin Scraper

1. **Set Up**: Open the EdJoin Scraper page in the Apify Console.
2. **Configure Input**: Set the search `keyword` (e.g., *Special Education*) and `location` (e.g., *California*).
3. **Limit Output**: Set `maxItems` to restrict the number of results collected to control costs.
4. **Choose Mode**: Enable `includeDescription` to visit detailed pages for direct emails and qualifications, or disable it for a super-fast, cheap listing-only query.
5. **Run**: Click the **Start** button. Once completed, download your data in JSON, CSV, Excel, or HTML format in the Output tab.

---

### Input Parameters

The scraper accepts these input configuration settings:

| Field | Type | Description | Default |
| --- | --- | --- | --- |
| `startUrls` | Array | Optional pre-filtered EdJoin search URLs to scrape. | `[]` |
| `keyword` | String | Search keyword for role, specialty, or district (e.g. "Teacher", "Secretary"). | `"Teacher"` |
| `location` | String | Geographic area (e.g. "California", "San Diego", "90210"). | `"California"` |
| `maxItems` | Integer | Maximum number of job records to collect. | `100` |
| `includeDescription` | Boolean | Whether to fetch detailed pages for HR emails, requirements, and logos. | `true` |
| `dateWithinDays` | Integer | Only include postings created within the last N days (0 = any time). | `0` |
| `maxConcurrency` | Integer | Maximum parallel page requests. | `8` |
| `proxyConfiguration` | Object | Proxy routing. Standard open WAF allows running without proxies. | `{"useApifyProxy": false}` |

---

### Output Structure

The scraper outputs fully normalized flat job rows with empty fields omitted. Here is a sample JSON representation:

```json
{
  "posting_id": 2234074,
  "title": "Secretary II (School) at Cajon Park - Pos#30024578",
  "district_name": "Santee School District",
  "city": "Santee",
  "county_name": "San Diego",
  "state_name": "California",
  "postal_code": "92071-2674",
  "address": "9625 Cuyamaca St.",
  "job_type": "Clerical / Secretarial Staff / Office Tech.",
  "employment_type": "FULL_TIME",
  "salary_info": "Salary Classification: 27",
  "pay_range_from": "Salary Classification: 27/ Step A",
  "pay_range_to": "Salary Classification: Step E",
  "pay_range_unit": "Monthly",
  "single_rate": null,
  "single_rate_unit": null,
  "contact_email": "brandi.medrano@santeesd.net",
  "date_posted": "2026-06-06T07:00:00.000Z",
  "deadline": "2026-06-12T23:00:00.000Z",
  "work_hours": "203 work days / 8.0 hrs. / 7:00 a.m. - 3:30 p.m.",
  "requirements": "MINIMUM QUALIFICATIONS / CERTIFICATIONS / AND APPLICATION PROCEDURE: See job description for a complete list of qualifications and requirements at www.santeesd.net; under the Human Resources department. Applications, transcripts, certification(s), and / or documentation MUST be submitted for each position...",
  "required_skills": "First Aid, CPR and AED Certificate (All three trainings required) Online training certificates accepted. Typing Certificate 50 nwpm (net words per minute)",
  "logo": "https://edjoinprodstoragewest.blob.core.windows.net/customerlogos/logo133892042317467324.png",
  "url": "https://www.edjoin.org/Home/JobPosting/2234074",
  "scraped_at": "2026-06-07T05:22:15.341Z"
}
````

***

### Output Fields Explanation

| Field Name | Type | Description |
| --- | --- | --- |
| `posting_id` | Number | Unique identifier for the vacancy posting. |
| `title` | String | Job position title. |
| `district_name` | String | School district or hiring agency name. |
| `city` | String | Primary city. |
| `county_name` | String | County name where the position resides. |
| `state_name` | String | State name (e.g. California). |
| `postal_code` | String | Location ZIP or postal code. |
| `address` | String | Physical street address of the district. |
| `job_type` | String | Broad classification group. |
| `employment_type` | String | Full Time, Part Time, or other employment status. |
| `salary_info` | String | Raw salary text. |
| `pay_range_from` | String | Stated lower bound of the pay schedule. |
| `pay_range_to` | String | Stated upper bound of the pay schedule. |
| `pay_range_unit` | String | Unit rate of the pay range (Monthly, Hourly, Annually). |
| `single_rate` | String | Stated flat pay rate if no range is given. |
| `contact_email` | String | Direct HR contact email address. |
| `date_posted` | String | ISO formatted publication date. |
| `deadline` | String | ISO formatted application closing date. |
| `work_hours` | String | Work shift, day, or calendar schedules. |
| `requirements` | String | Detailed qualifications description. |
| `required_skills` | String | Explicit certificates or typing requirements. |
| `logo` | String | Hiring organization logo URL. |
| `url` | String | Link to the original posting. |
| `scraped_at` | String | Scraping execution timestamp. |

***

### Cost Estimation & Pricing

Because this Actor uses an API-driven listing crawl and lightweight Cheerio detail fetch, it does not require running dynamic browser instances (Playwright/Puppeteer), which reduces compute overhead. It can be run successfully on standard datacenter IPs.

- **Standard platform rate**: **$1.99 per 1,000 results** (excludes micro platform execution fees).
- Running a 5,000 vacancy crawl will cost approximately $9.95 in bandwidth and compute units combined.

***

### FAQ, Disclaimers, and Support

- **Is scraping EdJoin legal?**
  Yes. This scraper extracts publicly available recruitment listings that districts intend to share with the public. It does not access private applicant data or require logging in. Ensure you comply with local regulations and respect server load limits by setting standard concurrency.
- **Can I run this on a schedule?**
  Yes. In the Apify Console, create a Schedule to trigger the actor daily, weekly, or monthly.
- **How can I submit suggestions or bugs?**
  Open an issue in the **Issues** tab on this Actor's page, or contact us through the Apify Console.

# Actor input Schema

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

Optional EdJoin search URLs to scrape. (e.g. https://www.edjoin.org/Home/Jobs?keywords=teacher...)

## `keyword` (type: `string`):

Search for specific jobs by role, specialty, or district (e.g., 'Special Education', 'Math Teacher', 'Santee').

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

Filter by city, county, state, or ZIP code (e.g., 'California', 'San Diego', 'Los Angeles').

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

Maximum number of job postings to scrape in total.

## `includeDescription` (type: `boolean`):

If enabled, the scraper visits each job's detailed page to extract requirements, skills, and HR contact emails. Otherwise, it only performs the fast listing API crawl.

## `dateWithinDays` (type: `integer`):

Only include jobs posted within the last N days (0 = any time).

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

Maximum number of requests handled in parallel.

## `maxRequestRetries` (type: `integer`):

Number of times a request will be retried if it fails.

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

Proxy settings for crawling. EdJoin has an open posture, so proxies are optional. Select 'None' or 'Custom' for optimal performance.

## Actor input object example

```json
{
  "startUrls": [],
  "keyword": "Teacher",
  "location": "California",
  "maxItems": 50,
  "includeDescription": true,
  "dateWithinDays": 0,
  "maxConcurrency": 8,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [],
    "keyword": "Teacher",
    "location": "California",
    "maxItems": 50,
    "dateWithinDays": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/edjoin-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": [],
    "keyword": "Teacher",
    "location": "California",
    "maxItems": 50,
    "dateWithinDays": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/edjoin-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": [],
  "keyword": "Teacher",
  "location": "California",
  "maxItems": 50,
  "dateWithinDays": 0
}' |
apify call getascraper/edjoin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EdJoin Jobs Scraper: Educator & School District Listings",
        "description": "Extract EdJoin teaching, administrative, and classified K-12 school job listings. Collect contact emails, salary ranges, deadlines, and requirements. Direct fast JSON API crawling with JSON-LD detail mapping. Best value at an affordable price.",
        "version": "0.1",
        "x-build-id": "XEUdnUTqxRND0uqSH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~edjoin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-edjoin-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/getascraper~edjoin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-edjoin-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/getascraper~edjoin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-edjoin-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": "Start URLs",
                        "type": "array",
                        "description": "Optional EdJoin search URLs to scrape. (e.g. https://www.edjoin.org/Home/Jobs?keywords=teacher...)",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Search for specific jobs by role, specialty, or district (e.g., 'Special Education', 'Math Teacher', 'Santee')."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter by city, county, state, or ZIP code (e.g., 'California', 'San Diego', 'Los Angeles')."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job postings to scrape in total.",
                        "default": 100
                    },
                    "includeDescription": {
                        "title": "Include Full Description",
                        "type": "boolean",
                        "description": "If enabled, the scraper visits each job's detailed page to extract requirements, skills, and HR contact emails. Otherwise, it only performs the fast listing API crawl.",
                        "default": true
                    },
                    "dateWithinDays": {
                        "title": "Date Within Days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs posted within the last N days (0 = any time).",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of requests handled in parallel.",
                        "default": 8
                    },
                    "maxRequestRetries": {
                        "title": "Max Request Retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of times a request will be retried if it fails.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for crawling. EdJoin has an open posture, so proxies are optional. Select 'None' or 'Custom' for optimal performance.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
