# Multi-ATS Job Board Scraper (Greenhouse, Lever, Ashby & More) (`gp005/multi-ats-jobs-scraper`) Actor

Fetch normalized job postings from Greenhouse, Lever, Ashby, SmartRecruiters, and Recruitee in one run. Returns title, location, department, employment type, description, and apply URL.

- **URL**: https://apify.com/gp005/multi-ats-jobs-scraper.md
- **Developed by:** [Geo](https://apify.com/gp005) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 job posting fetcheds

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

## Multi-ATS Job Board Scraper (Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee)

Fetch normalized job postings from five popular ATS platforms — Greenhouse, Lever, Ashby, SmartRecruiters, and Recruitee — in a single run. Get title, location, department, employment type, description, and apply URL, ready for pipelines, dashboards, or AI search.

### Why use this actor

Talent data is siloed across ATS platforms. A single company may post jobs on Greenhouse while a competitor uses Lever. Checking each platform manually, or building and maintaining five separate API integrations, is expensive.

This actor gives you one normalized job dataset from all five platforms with a single input. It's designed for:

- **Recruiters and sourcing teams** monitoring competitor or partner job boards
- **Product managers** analyzing hiring trends by department, location, or role
- **Data engineers** building talent-intel pipelines or company-growth signals
- **Developers** automating job alerts, career aggregators, or internal hiring dashboards
- **VC/PE analysts** tracking portfolio company headcount via live job postings

### Supported platforms

| Platform | Input example | Notes |
|---|---|---|
| Greenhouse | `{ "platform": "greenhouse", "companyId": "vercel" }` | Official JSON board API; per-job description fetch available |
| Lever | `{ "platform": "lever", "companyId": "netflix" }` | Official v0 postings API; crawl-delay honored |
| Ashby | `{ "platform": "ashby", "companyId": "notion" }` | Documented public posting-api endpoint |
| SmartRecruiters | `{ "platform": "smartrecruiters", "companyId": "McDonalds" }` | Official /v1/companies API |
| Recruitee | `{ "platform": "recruitee", "companyId": "acme" }` | Public /api/offers/ endpoint |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `sources` | array | required | List of `{platform, companyId}` objects |
| `maxJobsPerCompany` | integer | 100 | Max jobs per source, capped at 500 |
| `includeDescription` | boolean | true | Fetch and include full job description (plain text, HTML stripped) |
| `scrubPii` | boolean | true | Redact incidental email/phone in descriptions (GDPR) |
| `maxTotalChargeUsd` | number | 10.0 | Hard charge cap; actor stops gracefully when reached |

### Output

One dataset record per job posting. Fields:

```json
{
  "platform": "greenhouse",
  "companyId": "vercel",
  "jobId": "7612345",
  "title": "Senior Software Engineer, Edge Network",
  "location": "Remote",
  "department": "Engineering",
  "employmentType": null,
  "description": "Join Vercel's Edge Network team...",
  "applyUrl": "https://boards.greenhouse.io/vercel/jobs/7612345",
  "postedAt": null,
  "updatedAt": "2026-06-15T10:30:00Z",
  "fetchedAt": "2026-07-28T12:00:00Z"
}
````

Error records (invalid companyId, platform unreachable, zero results) are pushed to the dataset with `"status": "error"` and a plain-English `"reason"`, so the run never exits silently on bad input.

### Worked example + cost math

**Input:**

```json
{
  "sources": [
    { "platform": "greenhouse", "companyId": "vercel" },
    { "platform": "lever", "companyId": "netflix" },
    { "platform": "ashby", "companyId": "notion" }
  ],
  "maxJobsPerCompany": 50,
  "includeDescription": true
}
```

**Expected events and cost:**

| Event | Count | Unit price | Subtotal |
|---|---|---|---|
| `actor-start` | 1 | $0.01 | $0.01 |
| `job-fetched` | ~150 (50 per co.) | $0.003 | $0.45 |
| **Total** | | | **~$0.46** |

For 3 companies × 50 jobs each (150 jobs):

- Platform compute: ~0.005 CU × $0.40/CU = **~$0.002** (< 1% of revenue — well under the 30% cost cap)
- Revenue per run: **~$0.46**
- Gross margin: **~99%**

At $0.003 per job, a user fetching 1,000 jobs/month spends $3.00 — comparable to a manual analyst spending 2–3 hours.

### Compliance and rate limiting

- All five platforms are accessed via their **official, documented public APIs** (not HTML scraping)
- robots.txt honored on all target domains (Greenhouse: allows all; Lever: crawl-delay 1 honored; Ashby posting-api: not disallowed; SmartRecruiters /v1/companies/: explicitly allowed; Recruitee: Cloudflare-gated but public)
- Rate limited to **~1 request/second** per-tenant, well within each platform's tolerance
- Descriptive `User-Agent` header set on every request
- **Incidental PII** (recruiter emails/phones in descriptions) is redacted by default (`scrubPii: true`)
- No login-walled content, no candidate data, no session cookies

### Limitations

- **Workday** is not supported: Cloudflare + Akamai bot-management makes reliable access infeasible without a browser; a separate Workday actor is warranted
- SmartRecruiters descriptions require a per-job secondary fetch that would multiply requests; descriptions are omitted for that platform to stay polite
- Recruitee descriptions similarly require a per-posting HTML parse; omitted for the same reason
- Company IDs are platform-specific slugs — use the slug visible in the platform's job board URL (e.g. `boards.greenhouse.io/vercel` → `vercel`)

### Integrations

- **Apify API**: `POST /v2/acts/gp005~multi-ats-jobs-scraper/runs` — get a JSON feed of jobs in any pipeline
- **Make / n8n**: Trigger on schedule, filter by department or location, post to Slack/Sheets
- **MCP**: Available via the Apify MCP server (`apify/actors-mcp-server`) — let your AI assistant query live job postings
- **Webhooks**: Use `ACTOR_RUN_FINISHED` webhooks to push new jobs to your CRM, ATS, or data warehouse

### FAQ

**Which companyId should I use?**
Use the slug in the platform's job-board URL. For Greenhouse it's `boards.greenhouse.io/<slug>`, for Lever it's `jobs.lever.co/<slug>`, for Ashby it's `jobs.ashbyhq.com/<slug>`.

**Can I monitor new postings automatically?**
Yes — schedule the actor on a daily/weekly cadence and compare datasets across runs, or use Apify webhooks to get notified on completion.

**Does this work for private/internal job boards?**
No — only publicly accessible boards (no login required) are supported.

**Is this GDPR-compliant?**
The core data (job titles, departments, locations) is not personal data. Descriptions may incidentally include recruiter contact details; the `scrubPii: true` default redacts those. Users are responsible for their own downstream data handling.

**What if a company has no open jobs?**
An error record is pushed with `"reason": "No job postings found..."` so you always get a result, not a silent empty run.

# Actor input Schema

## `sources` (type: `array`):

List of ATS sources to fetch jobs from. Each entry needs a platform (greenhouse, lever, ashby, smartrecruiters, recruitee) and a companyId (the slug used in the platform's URL). Example: Vercel on Greenhouse uses companyId 'vercel'.

## `maxJobsPerCompany` (type: `integer`):

Maximum number of job postings to return per company/source. Capped at 500. Default: 100.

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

When true, fetch and include the full job description (HTML stripped to plain text). Some platforms require an extra request per job, which increases run time and cost. Default: true.

## `scrubPii` (type: `boolean`):

When true (default), redact email addresses and phone numbers that may appear incidentally in job descriptions (e.g. recruiter contacts). Recommended for GDPR compliance. Default: true.

## `maxTotalChargeUsd` (type: `number`):

Hard cap on the total charge for this run. The actor stops gracefully once this limit is reached. Mirrors ACTOR\_MAX\_TOTAL\_CHARGE\_USD. Default: 10.0.

## Actor input object example

```json
{
  "sources": [
    {
      "platform": "greenhouse",
      "companyId": "vercel"
    },
    {
      "platform": "lever",
      "companyId": "leverdemo"
    },
    {
      "platform": "ashby",
      "companyId": "ashby"
    }
  ],
  "maxJobsPerCompany": 50,
  "includeDescription": true,
  "scrubPii": true,
  "maxTotalChargeUsd": 5
}
```

# Actor output Schema

## `platform` (type: `string`):

ATS platform name (greenhouse, lever, ashby, smartrecruiters, recruitee, or 'N/A' for errors).

## `companyId` (type: `string`):

The company/board slug used to query the ATS.

## `jobId` (type: `string`):

Platform-native job posting ID.

## `title` (type: `string`):

Job title.

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

Office location or 'Remote'. Empty if not provided.

## `department` (type: `string`):

Team or department name. Empty if not provided.

## `employmentType` (type: `string`):

Employment type (Full-time, Part-time, Contract, etc.). Empty if not provided.

## `description` (type: `string`):

Plain-text job description (HTML stripped). Empty if includeDescription=false.

## `applyUrl` (type: `string`):

Direct URL to apply or view the posting.

## `postedAt` (type: `string`):

ISO 8601 date-time when the job was first posted. Empty if not provided.

## `updatedAt` (type: `string`):

ISO 8601 date-time when the posting was last updated. Empty if not provided.

## `fetchedAt` (type: `string`):

ISO 8601 date-time when this record was fetched.

## `status` (type: `string`):

Present only on error records; value is 'error'.

## `reason` (type: `string`):

Present only on error records; describes what went wrong.

# 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 = {
    "sources": [
        {
            "platform": "greenhouse",
            "companyId": "vercel"
        },
        {
            "platform": "lever",
            "companyId": "leverdemo"
        },
        {
            "platform": "ashby",
            "companyId": "ashby"
        }
    ],
    "maxJobsPerCompany": 50,
    "includeDescription": true,
    "scrubPii": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("gp005/multi-ats-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 = {
    "sources": [
        {
            "platform": "greenhouse",
            "companyId": "vercel",
        },
        {
            "platform": "lever",
            "companyId": "leverdemo",
        },
        {
            "platform": "ashby",
            "companyId": "ashby",
        },
    ],
    "maxJobsPerCompany": 50,
    "includeDescription": True,
    "scrubPii": True,
}

# Run the Actor and wait for it to finish
run = client.actor("gp005/multi-ats-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 '{
  "sources": [
    {
      "platform": "greenhouse",
      "companyId": "vercel"
    },
    {
      "platform": "lever",
      "companyId": "leverdemo"
    },
    {
      "platform": "ashby",
      "companyId": "ashby"
    }
  ],
  "maxJobsPerCompany": 50,
  "includeDescription": true,
  "scrubPii": true
}' |
apify call gp005/multi-ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-ATS Job Board Scraper (Greenhouse, Lever, Ashby & More)",
        "description": "Fetch normalized job postings from Greenhouse, Lever, Ashby, SmartRecruiters, and Recruitee in one run. Returns title, location, department, employment type, description, and apply URL.",
        "version": "0.1",
        "x-build-id": "Pgk0XXvdchyDIRKVf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/gp005~multi-ats-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-gp005-multi-ats-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/gp005~multi-ats-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-gp005-multi-ats-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/gp005~multi-ats-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-gp005-multi-ats-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": [
                    "sources"
                ],
                "properties": {
                    "sources": {
                        "title": "Job board sources",
                        "type": "array",
                        "description": "List of ATS sources to fetch jobs from. Each entry needs a platform (greenhouse, lever, ashby, smartrecruiters, recruitee) and a companyId (the slug used in the platform's URL). Example: Vercel on Greenhouse uses companyId 'vercel'.",
                        "items": {
                            "type": "object"
                        }
                    },
                    "maxJobsPerCompany": {
                        "title": "Max jobs per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of job postings to return per company/source. Capped at 500. Default: 100.",
                        "default": 100
                    },
                    "includeDescription": {
                        "title": "Include job description text",
                        "type": "boolean",
                        "description": "When true, fetch and include the full job description (HTML stripped to plain text). Some platforms require an extra request per job, which increases run time and cost. Default: true.",
                        "default": true
                    },
                    "scrubPii": {
                        "title": "Scrub incidental PII",
                        "type": "boolean",
                        "description": "When true (default), redact email addresses and phone numbers that may appear incidentally in job descriptions (e.g. recruiter contacts). Recommended for GDPR compliance. Default: true.",
                        "default": true
                    },
                    "maxTotalChargeUsd": {
                        "title": "Max total charge (USD)",
                        "minimum": 0.01,
                        "type": "number",
                        "description": "Hard cap on the total charge for this run. The actor stops gracefully once this limit is reached. Mirrors ACTOR_MAX_TOTAL_CHARGE_USD. Default: 10.0.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```