# Greenhouse Jobs API & Hiring Signals (`lirafrt/greenhouse-jobs-hiring-signals`) Actor

Export public Greenhouse jobs as normalized records with filters, optional employer-published pay ranges, stable hashes, and free hiring summaries.

- **URL**: https://apify.com/lirafrt/greenhouse-jobs-hiring-signals.md
- **Developed by:** [Murilo Lira](https://apify.com/lirafrt) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 greenhouse 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 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

## Greenhouse Jobs API & Hiring Signals

Export published jobs from one or more Greenhouse Job Boards as clean JSON, CSV, or Excel-ready records. Filter by keyword, location, department, date, or explicit remote status, optionally fetch employer-published pay ranges, and receive a deterministic hiring summary for each company.

This Actor uses Greenhouse's documented public Job Board API. Greenhouse states that Job Board data is public and that authentication is not required for `GET` endpoints. No proxy, login, cookie, LLM, or third-party API key is required.

### What you get

Each `job` record can include:

- company and Greenhouse board token;
- public job ID, internal job ID, and requisition ID when exposed;
- title, location, department, office, and language;
- first-published, updated, and application-deadline timestamps;
- cleaned description text and source HTML;
- explicit `remote`, `hybrid`, or `onsite` labels when observable;
- employer-published pay ranges when optional detail enrichment is enabled;
- application URL, source API URL, and a stable content hash;
- raw source payload only when requested.

Each `hiring-summary` record contains source, matched, and published job counts; department and location distributions; explicit remote and disclosed-salary counts; and the newest observed update.

Unknown source values remain `null`. The Actor does not invent salary, workplace type, publication date, or company metadata.

### Input example

```json
{
  "boards": ["stripe", "https://boards.greenhouse.io/cloudflare"],
  "keywords": ["data", "machine learning"],
  "excludeKeywords": ["intern"],
  "locations": ["United States", "Remote"],
  "maxJobs": 250,
  "includeContent": true,
  "includePayTransparency": true,
  "maxPayDetails": 50,
  "includeSummary": true
}
````

The board token is normally the company segment in a Greenhouse URL. For example, the token in `https://boards.greenhouse.io/example` is `example`. Official board and API URLs are also accepted and normalized.

### Output example

```json
{
  "recordType": "job",
  "source": "greenhouse",
  "boardToken": "example",
  "companyName": "Example, Inc.",
  "jobId": "123456",
  "internalJobId": "7890",
  "requisitionId": "ENG-42",
  "title": "Senior Data Engineer",
  "location": "Remote - US",
  "workplaceType": "remote",
  "departments": ["Engineering"],
  "offices": ["United States"],
  "language": "en",
  "firstPublishedAt": "2026-06-01T16:00:00Z",
  "updatedAt": "2026-07-10T16:00:00Z",
  "applicationDeadline": null,
  "descriptionText": "Build and operate reliable data systems...",
  "descriptionHtml": "<p>Build and operate reliable data systems...</p>",
  "salaryRanges": [
    {
      "minimum": 120000,
      "maximum": 180000,
      "currency": "USD",
      "interval": "YEAR",
      "title": "US salary range",
      "description": "Base salary"
    }
  ],
  "applicationUrl": "https://boards.greenhouse.io/example/jobs/123456",
  "sourceApiUrl": "https://boards-api.greenhouse.io/v1/boards/example/jobs/123456",
  "contentHash": "e7b9...",
  "collectedAt": "2026-07-17T12:00:00Z",
  "metadata": null,
  "raw": null
}
```

### Filtering behavior

- `keywords` uses OR matching across title, location, description, and department.
- `excludeKeywords` removes a job when any term matches the same fields.
- `locations` and `departments` use case-insensitive substring matching against the corresponding published fields.
- `remoteOnly` keeps only jobs explicitly marked remote in title or location. It does not treat missing location as remote.
- `updatedAfter` is inclusive. Jobs whose update date is missing are preserved rather than guessed.
- `maxJobs` is a global cap across all boards.

Filtering happens after one list request per board and before optional pay-detail requests.

### Cost controls

The cheapest mode is `includeContent: false`, `includePayTransparency: false`, and a small `maxJobs`. A normal run makes one public request per board. Pay enrichment adds at most `maxPayDetails` requests globally, never per board.

The Actor is designed for 256 MB of memory and has no proxy or model-inference cost. Store pricing is **$0.0012 per published `greenhouse_job`** (US$1.20 per 1,000 jobs), plus a one-time **$0.00005** `apify-actor-start` event per run. Hiring summaries are included at no extra charge.

### API usage

After the Actor is published, it can be called with any Apify API client. The default dataset contains both jobs and summaries; filter on `recordType` when only one type is needed. `RUN_SUMMARY` in the default key-value store reports successful and failed boards, request totals, publication totals, and charge-limit status.

### Limits and responsible use

- Only currently published jobs exposed by Greenhouse are returned.
- A valid board can legitimately contain zero jobs.
- Pay ranges are returned only when the employer exposes them through Greenhouse.
- Workplace labels are conservative text classifications, not employer guarantees.
- Board failures are isolated. The run continues when at least one requested board succeeds.
- The Actor only reads documented public `GET` endpoints and never submits applications.
- Respect applicable laws, the source's terms, and job-posting rights in your use and redistribution of the data.

### Support

For a reproducible issue, include the board token, a minimal redacted input, run ID, expected result, and observed result. Never post an Apify token or private applicant data.

# Actor input Schema

## `boards` (type: `array`):

Board tokens or official Greenhouse board URLs. The token is the company segment in boards.greenhouse.io/company.

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

Global maximum number of job records written. Hiring summaries do not count toward this limit.

## `includeContent` (type: `boolean`):

Include cleaned text and source HTML for every matched job.

## `includePayTransparency` (type: `boolean`):

Make one documented job-detail request per selected job, up to maxPayDetails, to collect employer-published pay ranges.

## `maxPayDetails` (type: `integer`):

Cap extra job-detail requests. Keep pay enrichment disabled for the lowest cost.

## `keywords` (type: `array`):

Keep jobs containing at least one term in title, location, description, or department. Blank means all jobs.

## `excludeKeywords` (type: `array`):

Drop jobs containing any term in title, location, description, or department.

## `locations` (type: `array`):

Keep jobs whose published location contains at least one term.

## `departments` (type: `array`):

Keep jobs whose published department contains at least one term.

## `remoteOnly` (type: `boolean`):

Keep only jobs explicitly marked remote in title or location. Ambiguous jobs are not guessed.

## `updatedAfter` (type: `string`):

Optional inclusive UTC date filter. Jobs with an unknown update date are preserved.

## `includeSummary` (type: `boolean`):

Write one summary per successful board with job, department, location, remote, salary, and freshness counts.

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

Concurrent board and optional detail requests.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## `maxRetries` (type: `integer`):

Retries for rate limits, timeouts, and transient server errors.

## `includeRaw` (type: `boolean`):

Attach the Greenhouse payload for debugging. This increases dataset size.

## Actor input object example

```json
{
  "boards": [
    "stripe",
    "https://boards.greenhouse.io/cloudflare"
  ],
  "maxJobs": 1000,
  "includeContent": true,
  "includePayTransparency": false,
  "maxPayDetails": 100,
  "keywords": [],
  "excludeKeywords": [],
  "locations": [],
  "departments": [],
  "remoteOnly": false,
  "includeSummary": true,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 20,
  "maxRetries": 2,
  "includeRaw": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized public jobs and records whose recordType is hiring-summary.

## `runSummary` (type: `string`):

Provider outcomes, request counts, publication totals, and charge-limit state.

# 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 = {
    "boards": [
        "stripe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lirafrt/greenhouse-jobs-hiring-signals").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 = { "boards": ["stripe"] }

# Run the Actor and wait for it to finish
run = client.actor("lirafrt/greenhouse-jobs-hiring-signals").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 '{
  "boards": [
    "stripe"
  ]
}' |
apify call lirafrt/greenhouse-jobs-hiring-signals --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greenhouse Jobs API & Hiring Signals",
        "description": "Export public Greenhouse jobs as normalized records with filters, optional employer-published pay ranges, stable hashes, and free hiring summaries.",
        "version": "0.1",
        "x-build-id": "x2xmccfW550aeHWv5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lirafrt~greenhouse-jobs-hiring-signals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lirafrt-greenhouse-jobs-hiring-signals",
                "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/lirafrt~greenhouse-jobs-hiring-signals/runs": {
            "post": {
                "operationId": "runs-sync-lirafrt-greenhouse-jobs-hiring-signals",
                "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/lirafrt~greenhouse-jobs-hiring-signals/run-sync": {
            "post": {
                "operationId": "run-sync-lirafrt-greenhouse-jobs-hiring-signals",
                "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": [
                    "boards"
                ],
                "properties": {
                    "boards": {
                        "title": "Greenhouse boards",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Board tokens or official Greenhouse board URLs. The token is the company segment in boards.greenhouse.io/company.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 300
                        }
                    },
                    "maxJobs": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Global maximum number of job records written. Hiring summaries do not count toward this limit.",
                        "default": 1000
                    },
                    "includeContent": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Include cleaned text and source HTML for every matched job.",
                        "default": true
                    },
                    "includePayTransparency": {
                        "title": "Fetch disclosed pay ranges",
                        "type": "boolean",
                        "description": "Make one documented job-detail request per selected job, up to maxPayDetails, to collect employer-published pay ranges.",
                        "default": false
                    },
                    "maxPayDetails": {
                        "title": "Maximum pay-detail requests",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap extra job-detail requests. Keep pay enrichment disabled for the lowest cost.",
                        "default": 100
                    },
                    "keywords": {
                        "title": "Include keywords",
                        "maxItems": 30,
                        "type": "array",
                        "description": "Keep jobs containing at least one term in title, location, description, or department. Blank means all jobs.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        },
                        "default": []
                    },
                    "excludeKeywords": {
                        "title": "Exclude keywords",
                        "maxItems": 30,
                        "type": "array",
                        "description": "Drop jobs containing any term in title, location, description, or department.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        },
                        "default": []
                    },
                    "locations": {
                        "title": "Locations",
                        "maxItems": 30,
                        "type": "array",
                        "description": "Keep jobs whose published location contains at least one term.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        },
                        "default": []
                    },
                    "departments": {
                        "title": "Departments",
                        "maxItems": 30,
                        "type": "array",
                        "description": "Keep jobs whose published department contains at least one term.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 100
                        },
                        "default": []
                    },
                    "remoteOnly": {
                        "title": "Explicitly remote only",
                        "type": "boolean",
                        "description": "Keep only jobs explicitly marked remote in title or location. Ambiguous jobs are not guessed.",
                        "default": false
                    },
                    "updatedAfter": {
                        "title": "Updated on or after",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Optional inclusive UTC date filter. Jobs with an unknown update date are preserved."
                    },
                    "includeSummary": {
                        "title": "Publish hiring summaries",
                        "type": "boolean",
                        "description": "Write one summary per successful board with job, department, location, remote, salary, and freshness counts.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Concurrent board and optional detail requests.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 20
                    },
                    "maxRetries": {
                        "title": "Maximum retries",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Retries for rate limits, timeouts, and transient server errors.",
                        "default": 2
                    },
                    "includeRaw": {
                        "title": "Include raw source job",
                        "type": "boolean",
                        "description": "Attach the Greenhouse payload for debugging. This increases dataset size.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
