# Facebook User Search Scraper (`scraper-engine/facebook-user-search-scraper`) Actor

🔎 Facebook User Search Scraper extracts public profile data from Facebook search results—names, profile links, locations & keywords—at scale. 🚀 Perfect for lead gen, recruiting, and research. ✅ Public data only, consent-first, and TOS/GDPR compliant.

- **URL**: https://apify.com/scraper-engine/facebook-user-search-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Facebook User Search Scraper

The Facebook User Search Scraper is a fast, reliable Facebook user scraper that discovers profiles via Google search and extracts public profile data at scale. It solves the tedious, manual process of locating people and collecting consistent details by automating a full Facebook people search scraper workflow from discovery to data extraction. Built for marketers, developers, data analysts, and researchers, this Facebook user search tool delivers clean, structured outputs you can pipe into enrichment, analytics, or outreach. With search-powered discovery and a consistent output schema, it enables large-scale Facebook user search automation without login.

### What data / output can you get?

Below are the exact fields this Facebook profile scraper saves to the dataset for each profile. Fields are included when publicly visible and found on the page.

| Data type | Description | Example value |
| --- | --- | --- |
| name | Full name from the profile | Mark Zuckerberg |
| profileImage | Main profile picture URL | https://lookaside.fbsbx.com/...p480x480... |
| coverImage | Cover photo URL (falls back to profileImage when needed) | https://lookaside.fbsbx.com/...s960x960... |
| images | Array of additional public photo URLs (up to 20) | ["https://scontent.xx.fbcdn.net/...", "https://..."] |
| userId | Numeric Facebook user ID when discoverable | 123456789 |
| profileUrl | Canonical profile URL (normalized) | https://www.facebook.com/profile.php?id=123456789 |
| userData | Array of work/education items extracted from About | [{"type":"work","text":"Meta","icon":"https://static.xx.fbcdn.net/...webp"}] |
| userData[].type | Item type | work |
| userData[].text | Display text for the entry | Software Engineer at Company |
| userData[].icon | Normalized icon URL for the entry | https://static.xx.fbcdn.net/rsrc.php/ye/r/Wc6P-qNdeGZ.webp |

Notes:
- Results are saved to the Apify dataset in real time and can be exported to JSON or CSV.
- If a field isn’t publicly available or found, it may be omitted from the item to keep the output clean.

### Key features

- 🚀 Search-powered discovery
  Uses Google to find Facebook profile URLs and then scrapes each profile’s public About data — a robust Facebook user finder tool for lead gen and research.

- 🔎 Precise result curation
  Normalizes and deduplicates profile URLs, focusing on real profiles and filtering non-person paths before scraping begins.

- 🧠 Structured work/education extraction
  Captures public Work and Education entries through a resilient pipeline that first queries structured endpoints and then falls back to HTML parsing when needed.

- 🌐 Smart proxy strategy
  Google queries run through a dedicated Google SERP proxy. Facebook requests start without a proxy and automatically fall back to datacenter → residential if blocked — ideal for a production-ready Facebook public data extractor.

- 📦 Consistent output schema
  Every item follows the same JSON structure: name, profileImage, coverImage, images, userId, profileUrl, userData — making downstream processing simple.

- 🔒 No login required
  Scrapes only publicly visible profile data; no cookies or session are required.

- 🧰 Developer-friendly
  Run on Apify and access results programmatically via the dataset API — a dependable Facebook user search API pattern for ETL pipelines.

- 🔁 Built for scale
  Control how many profiles you collect per query (up to 5,000), with real-time saves and detailed logs to monitor progress.

### How to use Facebook User Search Scraper - step by step

1. Sign in to your Apify account and open Apify Console.
2. Go to Actors and open “Facebook User Search Scraper”.
3. In Input, add queries (e.g., names, keywords) to discover profiles via Google search. Optionally, paste direct Facebook profile URLs into startUrls to scrape specific profiles.
4. Set maxItems to control how many profiles to process per run (1–5000; default 10).
5. (Optional) Configure proxyConfiguration for Facebook requests. Google search uses a dedicated SERP proxy automatically.
6. Click Start to launch. The actor will search Google, collect Facebook profile URLs, normalize/dedupe them, and scrape each profile’s public data.
7. Watch the Log for status updates, SERP collection info, and automatic proxy fallback messages.
8. Open the Output tab to view results. Export your data to JSON or CSV for analysis or enrichment.

Pro Tip: Combine query-based discovery with a curated list of startUrls to guarantee key profiles are included in each run — an efficient Facebook user lookup tool approach for CRM enrichment.

### Use cases

| Use case name | Description |
| --- | --- |
| B2B lead enrichment for sales | Build contact intelligence by discovering public Facebook profiles for names or keywords, then export structured data to feed your CRM. |
| Talent sourcing for recruiters | Identify candidates through Facebook people search scraper queries and extract public work/education entries for faster screening. |
| Academic/social research | Analyze public-profile attributes at scale using a Facebook user search crawler for demographic or sociological studies. |
| Brand/influencer mapping | Locate and catalog public profiles related to your brand or niche using keyword-based discovery and structured exports. |
| Data onboarding & deduplication | Normalize Facebook profile URLs and consolidate public metadata for identity resolution pipelines. |
| API pipeline automation | Run via Apify, fetch datasets via API, and schedule recurring jobs for automated enrichment — a practical Facebook user search automation flow. |

### Why choose Facebook User Search Scraper?

The Facebook User Search Scraper prioritizes precision, automation, and reliability for public profile discovery and extraction.

- ✅ Accurate discovery via SERP: Collects profile URLs through Google with targeted query strategies before scraping.
- 🧩 Consistent, structured output: Uniform fields for easy downstream processing in analytics and enrichment.
- ⚙️ Scale-ready: Control max profiles per run (up to 5,000) with real-time dataset saves.
- 👨‍💻 Developer access: Run on Apify and use the dataset API to integrate with your data stack — a dependable Facebook user search API pattern.
- 🔐 Public data only: Designed for public pages; no login or cookies needed.
- 🌐 Resilient proxy logic: Automatic fallback for Facebook requests — none → datacenter → residential — improves throughput across regions.
- 🛠️ More reliable than extensions: No fragile browser automation; built on server-side HTTP with robust parsing and normalization.

In short, this is a production-focused Facebook public profile scraper that outperforms unstable alternatives while keeping outputs clean and consistent.

### Is it legal / ethical to use Facebook User Search Scraper?

Yes — when done responsibly. This tool extracts only publicly available profile information and does not access private or authenticated data.

Guidelines for compliant use:
- Collect only public data and respect platform terms and applicable laws (e.g., GDPR/CCPA).
- Use the data responsibly for analysis, research, or enrichment — avoid spam or misuse.
- Do not attempt to access private profiles or gated content.
- Consult your legal team for edge cases or jurisdiction-specific questions.

### Input parameters & output format

Example input (query-based):
```json
{
  "queries": ["John Doe", "Jane Smith marketing"],
  "maxItems": 25,
  "startUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Example input (direct URLs):

```json
{
  "queries": [],
  "maxItems": 10,
  "startUrls": ["https://www.facebook.com/markzuckerberg"],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

Input parameters:

- queries (array, optional, default: none)
  - Description: Enter one or more search words. Each query is used to find Facebook profile links via Google.
- maxItems (integer, optional, default: 10)
  - Description: Maximum number of Facebook profiles to scrape in this run (1–5000).
- startUrls (array, optional, default: none)
  - Description: Paste Facebook profile URLs to scrape in addition to query results. Leave empty to use only search results.
- proxyConfiguration (object, optional, default: none)
  - Description: Proxy configuration for Facebook requests. Search uses a dedicated Google SERP proxy automatically.

Notes:

- None of the fields are strictly required, but provide at least queries or startUrls to produce results.

Example dataset item (output):

```json
{
  "name": "John Doe",
  "profileImage": "https://lookaside.fbsbx.com/...p480x480...",
  "coverImage": "https://lookaside.fbsbx.com/...s960x960...",
  "images": [
    "https://scontent.xx.fbcdn.net/...",
    "https://scontent.xx.fbcdn.net/..."
  ],
  "userId": "123456789",
  "profileUrl": "https://www.facebook.com/profile.php?id=123456789",
  "userData": [
    { "type": "work", "text": "Software Engineer at Company", "icon": "https://static.xx.fbcdn.net/rsrc.php/ye/r/Wc6P-qNdeGZ.webp" },
    { "type": "education", "text": "Studied at University", "icon": "https://static.xx.fbcdn.net/rsrc.php/v3/y5/r/TJztmYBP2MH.png" }
  ]
}
```

Field availability:

- Fields are included when found; if a value isn’t available publicly, that field may be omitted from the item.

### FAQ

#### Do I need to log in to scrape Facebook profiles?

No. The scraper is designed for public pages and does not require login or cookies. It fetches only publicly visible data.

#### How many profiles can I scrape per run?

You can set maxItems up to 5,000 per run. The tool deduplicates and normalizes URLs, then processes up to your configured limit.

#### Can I scrape specific profiles without using search?

Yes. Use startUrls to paste direct Facebook profile URLs. You can combine startUrls with queries in the same run.

#### What data fields are included in the output?

Each item includes name, profileImage, coverImage, images, userId, profileUrl, and userData (work/education entries with type, text, icon). Fields are included when publicly available.

#### Does this use the Facebook Graph API?

No. It collects publicly available profile information by fetching profile pages and related resources. It functions as a Facebook public profile scraper without relying on the public Graph API.

#### How does the proxy work?

Google search uses a dedicated Google SERP proxy for reliable discovery. Facebook requests start without a proxy and automatically fall back to datacenter, then residential if blocked.

#### Can I automate this as a Facebook user search API workflow?

Yes. Run the actor on Apify and consume results via the dataset API. This is a reliable pattern for Facebook user search automation and integration into ETL pipelines.

#### In which formats can I export results?

You can export results from the Apify dataset to JSON or CSV directly from the platform or via the API.

### Closing CTA / Final thoughts

The Facebook User Search Scraper is built for scalable, reliable discovery and extraction of public Facebook profile data. It combines SERP-powered discovery, resilient scraping, and a consistent output schema to streamline enrichment, research, and analytics.

Marketers, recruiters, analysts, and developers can quickly collect clean profile data (names, images, user IDs, and public work/education) and export to JSON/CSV. Developers can orchestrate runs and pull datasets through the Apify API to power automated workflows.

Start extracting smarter Facebook user insights today with a production-ready, automation-friendly Facebook user search tool built for scale.

# Actor input Schema

## `queries` (type: `array`):

📝 Enter one or more search words (e.g. a name). Each query is used to find Facebook profiles.

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

🎚️ Maximum number of Facebook profiles to scrape in this run (1–5000).

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

➕ Paste Facebook profile URLs here to scrape in addition to query results. Leave empty to use only search results.

## `proxyConfiguration` (type: `object`):

🔒 Search uses a dedicated proxy. For Facebook requests: no proxy by default; auto fallback to datacenter → residential if blocked.

## Actor input object example

```json
{
  "queries": [
    "mark"
  ],
  "maxItems": 10,
  "startUrls": [
    "https://www.facebook.com/markzuckerberg"
  ]
}
```

# 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 = {
    "queries": [
        "mark"
    ],
    "startUrls": [
        "https://www.facebook.com/markzuckerberg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/facebook-user-search-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 = {
    "queries": ["mark"],
    "startUrls": ["https://www.facebook.com/markzuckerberg"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/facebook-user-search-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 '{
  "queries": [
    "mark"
  ],
  "startUrls": [
    "https://www.facebook.com/markzuckerberg"
  ]
}' |
apify call scraper-engine/facebook-user-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook User Search Scraper",
        "description": "🔎 Facebook User Search Scraper extracts public profile data from Facebook search results—names, profile links, locations & keywords—at scale. 🚀 Perfect for lead gen, recruiting, and research. ✅ Public data only, consent-first, and TOS/GDPR compliant.",
        "version": "0.1",
        "x-build-id": "cQgXRcoxKCq7qGeNM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~facebook-user-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-facebook-user-search-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/scraper-engine~facebook-user-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-facebook-user-search-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/scraper-engine~facebook-user-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-facebook-user-search-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": {
                    "queries": {
                        "title": "🔤 Search queries",
                        "type": "array",
                        "description": "📝 Enter one or more search words (e.g. a name). Each query is used to find Facebook profiles.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "📊 Max profiles per query",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "🎚️ Maximum number of Facebook profiles to scrape in this run (1–5000).",
                        "default": 10
                    },
                    "startUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "➕ Paste Facebook profile URLs here to scrape in addition to query results. Leave empty to use only search results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "🔒 Search uses a dedicated proxy. For Facebook requests: no proxy by default; auto fallback to datacenter → residential if blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```