# Teamtailor Jobs Scraper (`automation-lab/teamtailor-jobs-scraper`) Actor

Extract public Teamtailor jobs into structured feeds with titles, departments, locations, descriptions, apply URLs, and JobPosting metadata.

- **URL**: https://apify.com/automation-lab/teamtailor-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Teamtailor Jobs Scraper

Extract public jobs from Teamtailor-hosted career pages into clean, structured datasets.

### What does Teamtailor Jobs Scraper do?

Teamtailor Jobs Scraper turns public Teamtailor career boards into normalized job records.

It accepts Teamtailor career-site URLs, `/jobs` listing URLs, or direct job detail URLs.

The scraper discovers public job links from listing pages.

It can also open every job detail page.

Detail pages are enriched from schema.org `JobPosting` JSON-LD when available.

That means you get fields such as title, company, department, location, employment type, posted date, description, apply URL, and source URL.

The actor is HTTP-first.

It does not require login credentials.

It does not automate a browser for the normal workflow.

It is designed for recurring job feed collection and hiring-market monitoring.

### Who is it for?

Recruiters can monitor competitors' public openings.

Job aggregators can pull Teamtailor-powered career pages into their own feeds.

Hiring-intelligence teams can track departments, regions, and job volume over time.

Sales teams can identify companies hiring for roles that indicate buying intent.

Data teams can normalize Teamtailor job postings before loading them into a warehouse.

Founders and operators can watch hiring activity across selected companies.

Agencies can build alerts for specific job titles and locations.

### Why use this scraper?

Teamtailor powers many branded career sites.

Manual copying is slow and error-prone.

Different career sites expose similar data in slightly different HTML layouts.

This actor focuses on the Teamtailor pattern and returns one consistent schema.

You can schedule it on Apify.

You can export results as JSON, CSV, Excel, XML, RSS, or via API.

You can connect the dataset to Google Sheets, Make, Zapier, Clay, Airtable, BigQuery, or your own application.

### What Teamtailor pages are supported?

Use a public Teamtailor career home page if it lists jobs.

Use a public `/jobs` listing URL such as `https://career.teamtailor.com/jobs`.

Use direct job detail URLs such as `https://career.teamtailor.com/jobs/8010892-midmarket-sdr-uk`.

Add multiple URLs in one run to combine career boards.

The actor only collects publicly visible pages.

It does not access private candidates, internal hiring pipelines, or recruiter accounts.

### Data you can extract

| Field | Description |
| --- | --- |
| `title` | Job title |
| `companyName` | Hiring company or career-site name |
| `department` | Department or team from the listing card |
| `location` | Human-readable location |
| `city` | City from structured job data |
| `region` | Region from structured job data |
| `country` | Country from structured job data |
| `remoteStatus` | Remote/hybrid/on-site text when available |
| `employmentType` | Employment type such as `FULL_TIME` |
| `datePosted` | Posted date from JobPosting metadata |
| `validThrough` | Closing date when supplied |
| `description` | Plain-text job description |
| `descriptionHtml` | HTML description from structured data |
| `applyUrl` | Best available apply URL |
| `jobId` | Teamtailor job identifier |
| `jobUrl` | Canonical job page URL |
| `sourceUrl` | Input/listing URL where the job was found |
| `scrapedAt` | Timestamp when the record was saved |

### How much does it cost to scrape Teamtailor jobs?

This actor uses Apify pay-per-event pricing.

A small start event is charged once per run.

A result event is charged for each saved job record.

The default input is intentionally small so first runs stay inexpensive.

Final live pricing is visible on the Apify actor page before you run it.

For recurring monitoring, set `maxItems` to the volume you actually need.

### Quick start

1. Open the actor on Apify.

2. Add one or more Teamtailor career-site URLs.

3. Keep `Fetch job details` enabled for full descriptions and JobPosting metadata.

4. Set `Maximum jobs` to your desired limit.

5. Run the actor.

6. Export the dataset or connect it to your workflow.

### Input settings

#### Career site or job URLs

Add Teamtailor URLs in the `startUrls` field.

You can mix listing pages and direct job pages.

Example:

```json
{
  "startUrls": [
    { "url": "https://career.teamtailor.com/jobs" }
  ],
  "maxItems": 25,
  "includeDetails": true,
  "requestDelayMs": 150
}
````

#### Maximum jobs

`maxItems` controls the total number of records saved across all input URLs.

Use a low value for tests.

Use a higher value for scheduled collection.

#### Fetch job details

`includeDetails` opens each job page.

This adds description, company, employment type, posted date, job ID, and structured location fields when available.

Turn it off when you only need fast listing-card output.

#### Delay between requests

`requestDelayMs` adds a polite pause between detail requests.

The default is conservative for normal use.

Increase it for very large career boards.

### Output example

```json
{
  "title": "MidMarket SDR - UK",
  "companyName": "Teamtailor",
  "department": "Sales",
  "location": "London, Europe, GB",
  "city": "London",
  "region": "Europe",
  "country": "GB",
  "employmentType": "FULL_TIME",
  "datePosted": "2026-07-02T15:46:44+02:00",
  "jobId": "8010892",
  "jobUrl": "https://career.teamtailor.com/jobs/8010892-midmarket-sdr-uk",
  "sourceUrl": "https://career.teamtailor.com/jobs",
  "scrapedAt": "2026-07-10T07:23:24.642Z"
}
```

### Tips for best results

Use the canonical Teamtailor `/jobs` page when possible.

Enable detail fetching if you need descriptions.

Add multiple companies as separate `startUrls`.

Use scheduling for daily or weekly hiring-intelligence snapshots.

Deduplicate downstream by `jobUrl` or `jobId`.

Store historical runs if you want to detect new, removed, or changed roles.

### Integrations

Send new jobs to Google Sheets for manual review.

Load results into BigQuery or Snowflake for trend analysis.

Trigger Zapier or Make scenarios when matching jobs appear.

Feed Clay enrichment workflows with hiring signals.

Create Slack alerts for specific departments or locations.

Use Apify webhooks to notify your application when a scheduled run finishes.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/teamtailor-jobs-scraper').call({
  startUrls: [{ url: 'https://career.teamtailor.com/jobs' }],
  maxItems: 25,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/teamtailor-jobs-scraper').call(run_input={
    'startUrls': [{'url': 'https://career.teamtailor.com/jobs'}],
    'maxItems': 25,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~teamtailor-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://career.teamtailor.com/jobs"}],"maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/teamtailor-jobs-scraper`

Claude Code setup:

```bash
claude mcp add apify-teamtailor-jobs --transport http https://mcp.apify.com/?tools=automation-lab/teamtailor-jobs-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-teamtailor-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/teamtailor-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the Teamtailor jobs at this URL and summarize roles by department."

- "Monitor this Teamtailor career page and tell me which jobs were added since last week."

- "Extract Teamtailor job descriptions and identify sales roles in London."

### Scheduling

Apify schedules let you run this actor automatically.

Daily schedules work well for job alerts.

Weekly schedules work well for hiring trend reports.

Use the same input each time.

Compare datasets by `jobUrl` to find newly added postings.

### Handling multiple companies

Add every Teamtailor career board to `startUrls`.

The actor processes sources in order.

It stops when `maxItems` is reached.

Set a higher `maxItems` when combining many companies.

Use `sourceUrl` to group results by originating career board.

### FAQ

#### Can I scrape any Teamtailor career site?

Yes, if the career site is public and exposes Teamtailor job pages without login.

#### Does this actor use a browser?

No. It uses HTTP and Cheerio for the baseline workflow, which keeps runs fast and inexpensive.

#### Can I schedule recurring Teamtailor job alerts?

Yes. Use Apify schedules and compare each run by `jobUrl` or `jobId`.

### Troubleshooting

#### I got fewer jobs than expected

Check `maxItems` first.

Some career sites have only a small number of public jobs.

If you entered a company home page that does not contain job links, try its `/jobs` page.

#### Descriptions are missing

Make sure `includeDetails` is enabled.

Some Teamtailor pages may omit structured descriptions or use custom blocks.

The actor still returns listing-card fields when details are unavailable.

#### A URL fails

Confirm the page is public and Teamtailor-hosted.

Private, expired, or redirected jobs may not be available.

### Legality and ethics

This actor collects public career-page data.

It does not bypass login walls.

It does not collect private candidate data.

You are responsible for using results in accordance with applicable laws, website terms, and privacy rules.

For personal data in job descriptions, apply your own retention and compliance policies.

### Related scrapers

Explore related Automation Lab actors for broader hiring intelligence:

- `https://apify.com/automation-lab/google-search-scraper`

- `https://apify.com/automation-lab/linkedin-company-scraper`

- `https://apify.com/automation-lab/website-contact-finder`

- `https://apify.com/automation-lab/clutch-scraper`

### Support

If a public Teamtailor career page does not parse correctly, share the run and input URL through Apify support.

Include whether `includeDetails` was enabled.

Include the number of jobs visible in the browser.

That helps reproduce layout-specific issues quickly.

# Actor input Schema

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

Teamtailor career page URLs, /jobs listing URLs, or direct /jobs/{id} job URLs. Add multiple career sites to build one combined jobs feed.

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

Maximum number of job records to save across all supplied Teamtailor sites.

## `includeDetails` (type: `boolean`):

Open each job page and merge structured JobPosting data such as description, employment type, posted date, company, and location.

## `requestDelayMs` (type: `integer`):

Small polite delay between job detail requests. Increase this for very large career sites.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://career.teamtailor.com/jobs"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "requestDelayMs": 150
}
```

# Actor output Schema

## `jobs` (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": [
        {
            "url": "https://career.teamtailor.com/jobs"
        }
    ],
    "maxItems": 20,
    "includeDetails": true,
    "requestDelayMs": 150
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/teamtailor-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 = {
    "startUrls": [{ "url": "https://career.teamtailor.com/jobs" }],
    "maxItems": 20,
    "includeDetails": True,
    "requestDelayMs": 150,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/teamtailor-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 '{
  "startUrls": [
    {
      "url": "https://career.teamtailor.com/jobs"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "requestDelayMs": 150
}' |
apify call automation-lab/teamtailor-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Teamtailor Jobs Scraper",
        "description": "Extract public Teamtailor jobs into structured feeds with titles, departments, locations, descriptions, apply URLs, and JobPosting metadata.",
        "version": "0.1",
        "x-build-id": "sc6tGcCDmztRqZBXo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~teamtailor-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-teamtailor-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/automation-lab~teamtailor-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-teamtailor-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/automation-lab~teamtailor-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-teamtailor-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Career site or job URLs",
                        "type": "array",
                        "description": "Teamtailor career page URLs, /jobs listing URLs, or direct /jobs/{id} job URLs. Add multiple career sites to build one combined jobs feed.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job records to save across all supplied Teamtailor sites.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch job details",
                        "type": "boolean",
                        "description": "Open each job page and merge structured JobPosting data such as description, employment type, posted date, company, and location.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Small polite delay between job detail requests. Increase this for very large career sites.",
                        "default": 150
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
