# BioSpace Jobs Scraper (`automation-lab/biospace-jobs-scraper`) Actor

Extract BioSpace job listings, companies, locations, summaries, descriptions, apply links, and posting metadata from public BioSpace pages.

- **URL**: https://apify.com/automation-lab/biospace-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

from $0.05 / 1,000 apify-default-dataset-item extracteds

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

## BioSpace Jobs Scraper

Extract public BioSpace job listings for biotech, pharma, and life-sciences hiring intelligence.

### What does BioSpace Jobs Scraper do?

BioSpace Jobs Scraper turns public BioSpace search and job-detail pages into structured datasets.

It collects job titles, companies, locations, listing summaries, full descriptions, BioSpace job URLs, apply URLs, company links, logo URLs, posting timestamps, expiration timestamps, source URLs, and scrape timestamps.

Use it when you need a repeatable BioSpace jobs extractor without manually copying pages into spreadsheets.

### Who is it for?

#### Recruiters

Track specialized life-sciences openings by keyword and export candidate-market signals.

#### Sales teams

Monitor which biotech and pharma companies are hiring for roles that indicate budget, growth, or pipeline activity.

#### Market intelligence teams

Build recurring datasets about hiring demand across therapeutic areas, research functions, and locations.

#### Data teams

Feed BioSpace job records into CRM enrichment, lead scoring, dashboards, and alerting workflows.

### Why use this actor?

- 🔎 Search BioSpace by keyword, role, skill, or company.
- 🧬 Extract life-sciences specific hiring signals from a niche jobs board.
- 📄 Enrich listings with full job descriptions from detail pages.
- 🔗 Save direct job, apply, company, and logo URLs.
- ⏱️ Run on demand or schedule recurring monitoring.
- 📦 Export results as JSON, CSV, Excel, XML, RSS, or via API.

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId` | BioSpace posting identifier |
| `title` | Job title |
| `company` | Hiring company or recruiter |
| `location` | Listed job location |
| `summary` | Short listing summary |
| `description` | Full job description from the detail page |
| `jobUrl` | Canonical BioSpace job URL |
| `applyUrl` | BioSpace apply URL when available |
| `companyUrl` | BioSpace company or employer profile URL |
| `logoUrl` | Company logo asset URL |
| `postedAt` | Posting timestamp when exposed by BioSpace metadata |
| `expiresAt` | Expiration timestamp when exposed by BioSpace metadata |
| `sourceUrl` | Page that produced the record |
| `sourceType` | `search` or `detail` |
| `sourceQuery` | Keyword query used for discovery |
| `scrapedAt` | ISO timestamp for extraction |

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

This actor uses pay-per-event pricing.

- Start event: small one-time run fee.
- Item event: one charge per saved BioSpace job record.
- Larger paid Apify plans receive lower per-item prices through tiered pricing.

Use a small `maxItems` value for smoke tests, then scale once the output matches your workflow.

### How to scrape BioSpace jobs

1. Open the actor on Apify.
2. Enter a keyword such as `scientist`, `oncology`, `bioinformatics`, or a company name.
3. Set `maxItems` to the number of jobs you need.
4. Keep `scrapeDetails` enabled when you need full descriptions and apply links.
5. Run the actor.
6. Download the dataset or connect it to your workflow.

### Input options

#### `keywords`

Search keyword, role, skill, company name, or hiring signal.

Example: `scientist`

#### `startUrls`

Optional BioSpace search result pages or individual job detail URLs.

Examples:

- `https://jobs.biospace.com/jobs/?keywords=scientist`
- `https://jobs.biospace.com/job/3053244/scientist-sr-scientist-research/`

#### `maxItems`

Maximum number of job records to save.

#### `scrapeDetails`

When enabled, the actor opens each BioSpace job detail page and extracts the long description, apply URL, and posting metadata.

### Example input: keyword search

```json
{
  "keywords": "scientist",
  "maxItems": 100,
  "scrapeDetails": true
}
````

### Example input: BioSpace URL list

```json
{
  "startUrls": [
    { "url": "https://jobs.biospace.com/jobs/?keywords=bioinformatics" },
    { "url": "https://jobs.biospace.com/job/3053244/scientist-sr-scientist-research/" }
  ],
  "maxItems": 50,
  "scrapeDetails": true
}
```

### Example output

```json
{
  "jobId": "3053244",
  "title": "Scientist / Sr. Scientist, Research",
  "company": "Visterra, Inc.",
  "location": "Waltham, Massachusetts",
  "summary": "The Opportunity We are seeking a highly motivated Scientist...",
  "description": "The Opportunity We are seeking a highly motivated Scientist...",
  "jobUrl": "https://jobs.biospace.com/job/3053244/scientist-sr-scientist-research/",
  "applyUrl": "https://jobs.biospace.com/logon?...",
  "companyUrl": "https://jobs.biospace.com/employer/...",
  "logoUrl": "https://jobs.biospace.com/getasset/...",
  "postedAt": "2026-06-05T04:59:50.973Z",
  "expiresAt": "2026-07-06T03:59:59.000Z",
  "sourceUrl": "https://jobs.biospace.com/job/3053244/scientist-sr-scientist-research/",
  "sourceType": "detail",
  "sourceQuery": "scientist",
  "scrapedAt": "2026-07-03T05:28:52.292Z"
}
```

### Tips for better results

- 🧪 Use targeted keywords like `clinical scientist`, `oncology`, `CMC`, or `bioinformatics`.
- 🏢 Search by company name when tracking specific accounts.
- 📉 Disable `scrapeDetails` for faster lightweight listing monitoring.
- 📈 Enable `scrapeDetails` when building CRM or market-intel records.
- 🔁 Schedule daily or weekly runs to monitor new postings.

### Integrations

#### CRM enrichment

Send BioSpace hiring signals into Salesforce, HubSpot, Airtable, or Clay.

#### Sales intelligence

Trigger alerts when target biotech accounts post jobs in commercial, clinical, or R\&D functions.

#### Market dashboards

Load records into BigQuery, Snowflake, Google Sheets, or a BI tool for trend analysis.

#### Recruiting operations

Export specialized job postings to internal sourcing dashboards or talent-market reports.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/biospace-jobs-scraper').call({
  keywords: 'scientist',
  maxItems: 100,
  scrapeDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/biospace-jobs-scraper').call(run_input={
    'keywords': 'bioinformatics',
    'maxItems': 100,
    'scrapeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~biospace-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":"scientist","maxItems":100,"scrapeDetails":true}'
```

### MCP usage

Connect this actor to Apify MCP so Claude Desktop or Claude Code can run BioSpace job extraction directly.

Add it in Claude Code:

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

Claude Desktop JSON configuration:

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

MCP URL:

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

Example prompts:

- "Run the BioSpace Jobs Scraper for oncology scientist jobs and summarize hiring companies."
- "Extract 100 BioSpace bioinformatics jobs and group them by location."
- "Monitor BioSpace for new clinical operations postings every week."

### Scheduling

Use Apify schedules to run recurring BioSpace searches.

Common schedules:

- Daily for active sales alerts.
- Weekly for market reports.
- Monthly for historical trend snapshots.

### Limitations

BioSpace controls its public pages and may change HTML structure, URLs, or metadata fields.

Some apply links may lead to BioSpace login or application flows.

The actor extracts public job data only and does not bypass login-only account features.

### FAQ

#### Why did I get fewer jobs than expected?

BioSpace may have fewer matching postings for a narrow keyword. Try a broader keyword or provide a search URL with more results.

#### Why is `applyUrl` a BioSpace login URL?

Some application flows require a BioSpace job seeker session. The actor records the public apply entry URL when it is exposed.

#### Why are some timestamps empty?

Posting and expiration timestamps are available when BioSpace exposes Open Graph article metadata on the job detail page.

### Legality and responsible use

This actor collects publicly available BioSpace job posting pages. You are responsible for using exported data in compliance with applicable laws, BioSpace terms, and your internal policies.

Do not use the actor to collect private account data or bypass access controls.

### Related scrapers

Explore related automation-lab actors for recruiting, lead generation, and company monitoring:

- https://apify.com/automation-lab/amazon-jobs-scraper
- https://apify.com/automation-lab/airbnb-careers-scraper
- https://apify.com/automation-lab/linkedin-profile-scraper
- https://apify.com/automation-lab/company-website-scraper

### Change monitoring workflow

Run the same keyword on a schedule and compare datasets by `jobId`.

New `jobId` values indicate newly discovered postings.

Expired or missing jobs can indicate closed requisitions.

### Data quality workflow

Use `jobUrl` as the stable row URL.

Use `jobId` as the stable BioSpace identifier.

Use `scrapedAt` to partition recurring exports.

### Performance notes

With `scrapeDetails` disabled, the actor only processes search listing pages and runs faster.

With `scrapeDetails` enabled, the actor visits each job detail page for richer records.

### Support

If a BioSpace page format changes or you need additional fields, open an issue on the actor page with an example input and run URL.

# Actor input Schema

## `keywords` (type: `string`):

Job title, skill, company, or life-sciences hiring signal to search on BioSpace.

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

Optional BioSpace search result pages or individual job detail URLs. If omitted, the actor builds a search URL from Keywords.

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

Maximum number of BioSpace job records to save.

## `scrapeDetails` (type: `boolean`):

Open each job detail page to extract the full description, apply URL, and posting metadata.

## Actor input object example

```json
{
  "keywords": "scientist",
  "startUrls": [
    {
      "url": "https://jobs.biospace.com/jobs/?keywords=scientist"
    }
  ],
  "maxItems": 20,
  "scrapeDetails": true
}
```

# Actor output Schema

## `overview` (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 = {
    "keywords": "scientist",
    "startUrls": [
        {
            "url": "https://jobs.biospace.com/jobs/?keywords=scientist"
        }
    ],
    "maxItems": 20,
    "scrapeDetails": true
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BioSpace Jobs Scraper",
        "description": "Extract BioSpace job listings, companies, locations, summaries, descriptions, apply links, and posting metadata from public BioSpace pages.",
        "version": "0.1",
        "x-build-id": "DaLj0ZGsCT57pl8ms"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~biospace-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-biospace-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~biospace-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-biospace-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~biospace-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-biospace-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",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title, skill, company, or life-sciences hiring signal to search on BioSpace.",
                        "default": "scientist"
                    },
                    "startUrls": {
                        "title": "BioSpace URLs",
                        "type": "array",
                        "description": "Optional BioSpace search result pages or individual job detail URLs. If omitted, the actor builds a search URL from Keywords.",
                        "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 BioSpace job records to save.",
                        "default": 20
                    },
                    "scrapeDetails": {
                        "title": "Scrape job details",
                        "type": "boolean",
                        "description": "Open each job detail page to extract the full description, apply URL, and posting metadata.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```