# Freelancer Jobs & Projects Scraper (`automation-lab/freelancer-scraper`) Actor

Scrape Freelancer.com jobs and projects by keyword or category. Extract budgets, bids, skills, descriptions, URLs, and posting signals.

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

## Freelancer Jobs & Projects Scraper

Scrape public Freelancer.com jobs and project listings by keyword, skill category, or direct jobs URL. Export project titles, URLs, budgets, bids, skills, descriptions, payment-verification signals, source search URLs, and scrape timestamps.

### What does Freelancer Jobs & Projects Scraper do?

Freelancer Jobs & Projects Scraper turns Freelancer.com project search pages into a clean dataset for lead generation, market research, and workflow automation.

It reads public Freelancer job listing pages such as `https://www.freelancer.com/jobs/python/`, follows pagination, deduplicates projects, and saves structured rows to the default Apify dataset.

You can use it to monitor new project demand, understand budget ranges, watch skill trends, or route fresh opportunities into your CRM.

### Who is it for?

- 🧑‍💼 Agencies that prospect companies posting work on Freelancer.
- 🧑‍💻 Freelancers that monitor high-fit projects by skill.
- 📊 Market researchers tracking demand for Python, data entry, scraping, AI, design, or other skills.
- 🧲 Sales teams building lead lists from public project posts.
- 🔔 Operators creating alerts for new freelance-market opportunities.

### Why use this scraper?

Manual Freelancer search is slow when you need repeatable exports, multiple keywords, and automation-ready data.

This actor gives you:

- structured JSON, CSV, Excel, XML, RSS, and HTML dataset exports;
- keyword and direct URL inputs;
- budget and bid fields for prioritization;
- skill arrays for filtering;
- public-page-only scraping with no login required;
- optional detail-page enrichment when you need longer descriptions.

### Data you can extract

| Field | Description |
| --- | --- |
| `projectId` | Project slug parsed from the Freelancer project URL. |
| `title` | Project title. |
| `url` | Public Freelancer project URL. |
| `budget` | Raw budget or average bid text shown on the listing. |
| `budgetMin` | First numeric budget value when available. |
| `budgetMax` | Second numeric budget value when available. |
| `currency` | Currency symbol or code when visible. |
| `averageBid` | Average bid text when Freelancer displays it. |
| `bidsCount` | Number of bids/proposals shown on the card. |
| `skills` | Freelancer skills/categories attached to the project. |
| `description` | Listing snippet or enriched detail description. |
| `postedOrRemainingTime` | Visible time signal such as days left. |
| `employerVerifiedPayment` | Payment verification signal when visible. |
| `sourceSearchUrl` | Listing page that produced the record. |
| `detailScraped` | Whether detail-page enrichment was attempted successfully. |
| `scrapedAt` | ISO timestamp for the scrape. |

### How much does it cost to scrape Freelancer projects?

The actor uses pay-per-event pricing: a small start fee and a per-project result event.

Exact prices are shown on the Apify Store pricing panel. You control spend with `maxItems`, `maxPagesPerSearch`, and `includeDetails`.

For the cheapest monitoring runs, keep `includeDetails` off and scrape listing cards only.

### Input options

#### `keywords`

Enter Freelancer skill/category slugs or natural keywords. Examples:

- `python`
- `data-entry`
- `web-scraping`
- `react-js`
- `virtual-assistant`

The actor converts these to public Freelancer `/jobs/<keyword>/` pages.

#### `startUrls`

Use this when you already have specific Freelancer jobs URLs.

Example:

```json
[
  { "url": "https://www.freelancer.com/jobs/python/" },
  { "url": "https://www.freelancer.com/jobs/data-entry/" }
]
````

#### `maxItems`

Maximum project rows to save across all searches.

#### `maxPagesPerSearch`

Maximum listing pages to scan for each keyword or start URL.

#### `includeDetails`

When enabled, the actor visits each public project page to enrich the record. This is slower and costs more compute, so leave it disabled for frequent monitoring.

### Example input

```json
{
  "keywords": ["python", "web-scraping"],
  "maxItems": 100,
  "maxPagesPerSearch": 5,
  "includeDetails": false
}
```

### Example output

```json
{
  "projectId": "automation/google-earth-water-tank-mapping",
  "title": "Google Earth Water Tank Mapping",
  "url": "https://www.freelancer.com/projects/automation/google-earth-water-tank-mapping",
  "budget": "$311",
  "budgetMin": 311,
  "budgetMax": 311,
  "currency": "$",
  "averageBid": "$311",
  "bidsCount": 48,
  "skills": ["Automation", "Data Analysis", "Data Entry", "Geolocation", "Python"],
  "description": "I have a large-scale mapping task...",
  "postedOrRemainingTime": "6 days left",
  "employerVerifiedPayment": true,
  "sourceSearchUrl": "https://www.freelancer.com/jobs/python/",
  "detailScraped": false,
  "scrapedAt": "2026-06-27T00:00:00.000Z"
}
```

### How to run it

1. Open the actor on Apify.
2. Add one or more `keywords` or `startUrls`.
3. Set `maxItems` to your desired dataset size.
4. Keep `includeDetails` off for fast monitoring, or turn it on for deeper project text.
5. Click **Start**.
6. Export results from the Dataset tab.

### Tips for better results

- Use Freelancer skill slugs such as `python`, `data-entry`, or `web-scraping`.
- Use multiple focused keywords instead of one broad query.
- Increase `maxPagesPerSearch` when you need older projects.
- Turn on detail pages only for smaller, high-value searches.
- Schedule the actor daily or hourly for demand monitoring.

### Integrations

Connect the dataset to:

- Google Sheets for lead review.
- Zapier or Make for alerts.
- Slack or Discord notifications for fresh jobs.
- Airtable or HubSpot for CRM enrichment.
- BigQuery, Snowflake, or S3 for market analytics.

### 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/freelancer-scraper').call({
  keywords: ['python'],
  maxItems: 100,
  includeDetails: false
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/freelancer-scraper').call(run_input={
    'keywords': ['python'],
    'maxItems': 100,
    'includeDetails': False,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~freelancer-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["python"],"maxItems":100,"includeDetails":false}'
```

### MCP integration

Use Apify MCP to call this scraper from Claude Desktop, Claude Code, or other MCP-compatible tools.

MCP endpoint:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Scrape 100 Python projects from Freelancer and summarize the most common skills."
- "Find recent web scraping jobs on Freelancer and rank them by budget."
- "Monitor data entry projects and alert me when a project has more than 20 bids."

### Scheduling ideas

- Run every morning for sales prospecting.
- Run every hour for competitive bidding workflows.
- Run weekly to track budget movement by skill.
- Run monthly to build freelance-market trend dashboards.

### Lead generation workflow

A common workflow is:

1. Scrape projects for target skills.
2. Filter by budget, bid count, and keywords.
3. Send promising project URLs to a CRM.
4. Assign outreach or bidding tasks to team members.
5. Track which categories generate the best conversion.

### Market research workflow

Researchers can group results by skills, budgets, and time windows to understand:

- which skills are in demand;
- average posted budgets;
- how competitive categories are;
- which niches attract many bids;
- which project types are recurring.

### FAQ

#### Can I scrape Freelancer without logging in?

Yes. This actor targets public Freelancer jobs and project pages only. It does not access private account areas, bidding workflows, or messages.

#### Can I monitor multiple skills in one run?

Yes. Add multiple `keywords` such as `python`, `web-scraping`, and `data-entry`; the actor scans each search and deduplicates project URLs.

### Troubleshooting

#### Why did I get fewer rows than `maxItems`?

The search may have fewer available pages than requested, Freelancer may omit duplicate projects, or your `maxPagesPerSearch` may be too low.

#### Why are some budgets null?

Freelancer pages do not always expose a clean min/max range. The actor saves raw text when visible and parsed numeric fields when possible.

#### Why is detail scraping slower?

Detail enrichment opens each project page. For large monitoring runs, listing-card extraction is usually enough and much faster.

### Legality and responsible use

This actor extracts publicly available Freelancer.com pages. You are responsible for using the data lawfully, respecting Freelancer's terms, and avoiding spam or abusive outreach.

Do not scrape private account data, messages, or login-only pages.

### Related scrapers

Explore other Automation Lab actors:

- https://apify.com/automation-lab/upwork-scraper
- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/company-contact-scraper

### Changelog

- Initial version: public Freelancer jobs/project search extraction with optional project detail enrichment.

### Support

If a Freelancer page structure changes or you need another output field, open an Apify issue with an example input and run URL.

# Actor input Schema

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

Freelancer job keywords or /jobs/ slugs to scrape, for example python, data-entry, web-scraping, react-js, or virtual-assistant.

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

Optional public Freelancer jobs/search URLs such as https://www.freelancer.com/jobs/python/ or https://www.freelancer.com/jobs/data-entry/.

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

Maximum Freelancer project cards to save across all keywords and start URLs.

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

Open each project page for additional visible detail. Leave off for faster high-volume monitoring.

## `maxPagesPerSearch` (type: `integer`):

Upper bound on Freelancer listing pages scanned per keyword or direct search URL.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": false,
  "maxPagesPerSearch": 5
}
```

# 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": [
        "python"
    ],
    "startUrls": [],
    "maxItems": 20,
    "includeDetails": false,
    "maxPagesPerSearch": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/freelancer-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": ["python"],
    "startUrls": [],
    "maxItems": 20,
    "includeDetails": False,
    "maxPagesPerSearch": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/freelancer-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": [
    "python"
  ],
  "startUrls": [],
  "maxItems": 20,
  "includeDetails": false,
  "maxPagesPerSearch": 5
}' |
apify call automation-lab/freelancer-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Freelancer Jobs & Projects Scraper",
        "description": "Scrape Freelancer.com jobs and projects by keyword or category. Extract budgets, bids, skills, descriptions, URLs, and posting signals.",
        "version": "0.1",
        "x-build-id": "XSidrHWB6GVVZ8uBh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~freelancer-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-freelancer-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~freelancer-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-freelancer-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~freelancer-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-freelancer-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 or skill/category slugs",
                        "type": "array",
                        "description": "Freelancer job keywords or /jobs/ slugs to scrape, for example python, data-entry, web-scraping, react-js, or virtual-assistant.",
                        "default": [
                            "python"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct Freelancer jobs URLs",
                        "type": "array",
                        "description": "Optional public Freelancer jobs/search URLs such as https://www.freelancer.com/jobs/python/ or https://www.freelancer.com/jobs/data-entry/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum projects",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Freelancer project cards to save across all keywords and start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Visit project detail pages",
                        "type": "boolean",
                        "description": "Open each project page for additional visible detail. Leave off for faster high-volume monitoring.",
                        "default": false
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Upper bound on Freelancer listing pages scanned per keyword or direct search URL.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
