# LinkedIn Profiles Discover (`easy_scraper/linkedin-profiles-discover`) Actor

Discover thousands of real LinkedIn profiles across 30 countries using native-language search. Build lead lists, recruit talent, or research markets in minutes — not days.

Find software engineers, founders, marketers, recruiters, and more with clean export-ready datasets.

- **URL**: https://apify.com/easy\_scraper/linkedin-profiles-discover.md
- **Developed by:** [easy scraper](https://apify.com/easy_scraper) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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

## 🔍 LinkedIn Profiles Discover

> **Find thousands of LinkedIn profiles in any niche, any country — in minutes.**

---

### 🚀 What is this?

LinkedIn Profiles Discover automatically finds real LinkedIn personal profiles matching any keyword — software engineers, marketing managers, recruiters, founders, and more — across **30 countries** in **their local language**.

Whether you're building lead generation lists, doing market research, or building your sales pipeline, this tool does in minutes what would take your team days.

---

### ✨ What to Expect

- 🌍 **Multi-country discovery** — target one or many countries simultaneously
- 🗣️ **Native language search** — finds profiles that only appear in Arabic, Japanese, Russian, Hindi, and more
- 📦 **Clean dataset output** — profile URL, name slug, Google snippet, and keyword for every profile
- ⚡ **Smart stopping** — automatically skips exhausted queries and stops the moment your target count is reached
- 💰 **Pay only for results** — you're charged per discovered profile, not per run

> 💡 **Pro tip:** For non-English countries, enter your keywords in the local language for dramatically better results.
> 
> | ❌ Less effective | ✅ Much better |
> |---|---|
> | `software engineer` → Egypt | `مهندس برمجيات` → Egypt |
> | `marketing manager` → Japan | `ソフトウェアエンジニア` → Japan |
> | `photographer` → Russia | `инженер-программист` → Russia |

---

### 📥 Input

Configure the actor from the Apify Console UI or pass a JSON input when using the API.

#### Input fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | `string[]` | ✅ Yes | — | Keywords to search for. Use the target country's language for best results. |
| `maxProfilesPerKeyword` | `number` | No | `100` | Max unique profiles to collect per keyword per country. |
| `countries` | `string[]` | No | `["US"]` | ISO country codes to target. See supported countries below. |

#### Input JSON example

```json
{
  "keywords": ["marketing manager", "software engineer"],
  "maxProfilesPerKeyword": 500,
  "countries": ["US", "GB", "AE"]
}
````

#### Arabic-market example (Middle East/North Africa)

```json
{
  "keywords": ["مهندس برمجيات", "مدير تسويق"],
  "maxProfilesPerKeyword": 1000,
  "countries": ["EG", "SA", "AE"]
}
```

#### Supported countries

| Code | Country | Search Language |
|---|---|---|
| `US` | 🇺🇸 United States | English |
| `GB` | 🇬🇧 United Kingdom | English |
| `CA` | 🇨🇦 Canada | English |
| `AU` | 🇦🇺 Australia | English |
| `IN` | 🇮🇳 India | Hindi |
| `CN` | 🇨🇳 China | Chinese |
| `JP` | 🇯🇵 Japan | Japanese |
| `KR` | 🇰🇷 South Korea | Korean |
| `RU` | 🇷🇺 Russia | Russian |
| `DE` | 🇩🇪 Germany | German |
| `FR` | 🇫🇷 France | French |
| `IT` | 🇮🇹 Italy | Italian |
| `ES` | 🇪🇸 Spain | Spanish |
| `BR` | 🇧🇷 Brazil | Portuguese |
| `MX` | 🇲🇽 Mexico | Spanish |
| `TR` | 🇹🇷 Turkey | Turkish |
| `SA` | 🇸🇦 Saudi Arabia | Arabic |
| `AE` | 🇦🇪 UAE | Arabic |
| `EG` | 🇪🇬 Egypt | Arabic |
| `IR` | 🇮🇷 Iran | Persian |
| `PK` | 🇵🇰 Pakistan | Urdu |
| `BD` | 🇧🇩 Bangladesh | Bengali |
| `NG` | 🇳🇬 Nigeria | English |
| `PH` | 🇵🇭 Philippines | English |
| `ID` | 🇮🇩 Indonesia | Indonesian |
| `VN` | 🇻🇳 Vietnam | Vietnamese |
| `TH` | 🇹🇭 Thailand | Thai |
| `NL` | 🇳🇱 Netherlands | Dutch |
| `ET` | 🇪🇹 Ethiopia | English |

***

### 📤 Output

Each discovered profile is saved as one row in the dataset.

#### Output JSON example

```json
{
  "profileUrl": "https://www.linkedin.com/in//john-doe-123/",
  "username": "john-doe-123",
  "snippet": "Senior Software Engineer at Google · San Francisco, CA",
  "keyword": "software engineer",
  "discoveredAt": "2025-05-09T14:32:01.000Z"
}
```

#### Output field reference

| Field | Type | Description |
|---|---|---|
| `profileUrl` | `string` | Full Instagram profile URL |
| `username` | `string` | Instagram LinkedIn profile slug |
| `snippet` | `string` | Google snippet — usually contains job title, company, and location |
| `keyword` | `string` | The keyword that led to this profile's discovery |
| `discoveredAt` | `string` | ISO timestamp of when the profile was found |

#### Export formats

Download your results from the Apify Console dataset tab in **JSON**, **CSV**, **Excel**, or **XML** — one click, no extra steps.

***

### 💳 Pricing

| Plan | Profiles per run | Cost |
|---|---|---|
| 🆓 **Free** | Up to **50** | $0 |
| 💎 **Pay per result** | Unlimited | **$1.50 per 1,000 profiles** |

You are charged only for profiles successfully delivered to your dataset. There are no charges for failed searches, empty pages, or duplicate profiles that were filtered out.

> **Example:** Discovering 5,000 profiles costs **$7.50**. Set your maximum charge per run in the Apify Console to stay within budget — the actor stops automatically when your limit is reached.

***

### ▶️ How to Run

#### Option 1 — Apify Console (no code)

1. Open the actor page on [Apify Store](https://apify.com/store)
2. Click **Try for free**
3. Fill in your keywords, select countries, and set your profile target
4. Click **Start** — results appear live in the **Output** tab
5. Download your dataset as CSV or JSON when complete

#### Option 2 — API

Run the actor programmatically from any language. Get your API token from **Apify Console → Settings → Integrations**.

**Start a run:**

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_USERNAME~linkedin-profiles-discover/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["software engineer"],
    "maxProfilesPerKeyword": 500,
    "countries": ["US", "GB"]
  }'
```

**Fetch results** (replace `DATASET_ID` from the run response):

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv" \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

#### Option 3 — JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client
  .actor('YOUR_USERNAME~linkedin-profiles-discover')
  .call({
    keywords: ['marketing manager'],
    maxProfilesPerKeyword: 1000,
    countries: ['US', 'CA'],
  });

const { items } = await client
  .dataset(run.defaultDatasetId)
  .listItems();

console.log(items);
```

#### Option 4 — Scheduled runs

Automate recurring discovery (e.g. weekly influencer list refresh):

1. Go to **Apify Console → Schedules → Create new**
2. Select this actor and paste your input JSON
3. Set your cron schedule (e.g. `0 9 * * 1` for every Monday at 9am)
4. Results are saved automatically to a new dataset each run

***

### ❓ FAQ

**How many profiles can I get per keyword?**
Hundreds to thousands depending on how broad the keyword is and how many countries you target. Common niches like "marketing manager" targeting the US can yield 500+ unique profiles.

**Will I get duplicate profiles?**
No. Deduplication is applied across all queries and countries — each profile URL appears only once in your dataset.

**Why do Arabic / Japanese / Chinese searches return better results with native keywords?**
Search engines index Instagram pages in the language the profile is written in. A search for `software engineer` in Arabic-speaking markets finds mostly English-bio profiles. Searching for `مهندس برمجيات` finds the locally popular creators your competitors aren't finding.

**What does the snippet field contain?**
It's the short description Google shows under each search result — usually the profile bio, follower count, or a recent caption. Useful for quick qualification without visiting each profile.

**Can I filter by follower count?**
Not directly in input — but the `snippet` field often contains follower counts (e.g. `511K followers`), which you can filter in your spreadsheet or downstream tool after export.

***

### 🤝 Support

Found an issue or have a feature request? Use the **Issues** tab on the actor page in Apify Console, or reach out via Apify support.

# Actor input Schema

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

Keywords to discover LinkedIn profiles for. Tip: use native-language keywords for non-English countries (e.g. "مدون سياحي" for Arabic, "旅行博主" for Chinese, "путешественник" for Russian).

## `maxProfilesPerKeyword` (type: `integer`):

Maximum unique Instagram profiles to collect per keyword per country. The on-demand queue stops fetching once this is reached — no wasted SERP requests.

## `countries` (type: `array`):

Select target countries. Each uses its own Google domain and proxy. US uses state names as modifiers. Non-Latin countries (AR, HI, ZH, JA, KO, etc.) use native script characters. ⚠️ For non-English countries enter keywords in the local language.

## Actor input object example

```json
{
  "keywords": [
    "software engineer",
    "marketing manager"
  ],
  "maxProfilesPerKeyword": 100,
  "countries": [
    "US"
  ]
}
```

# 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": [
        "software engineer",
        "marketing manager"
    ],
    "maxProfilesPerKeyword": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("easy_scraper/linkedin-profiles-discover").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": [
        "software engineer",
        "marketing manager",
    ],
    "maxProfilesPerKeyword": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("easy_scraper/linkedin-profiles-discover").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": [
    "software engineer",
    "marketing manager"
  ],
  "maxProfilesPerKeyword": 100
}' |
apify call easy_scraper/linkedin-profiles-discover --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=easy_scraper/linkedin-profiles-discover",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profiles Discover",
        "description": "Discover thousands of real LinkedIn profiles across 30 countries using native-language search. Build lead lists, recruit talent, or research markets in minutes — not days.\n\nFind software engineers, founders, marketers, recruiters, and more with clean export-ready datasets.",
        "version": "1.0",
        "x-build-id": "3CwExrj434DOZ4M9V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/easy_scraper~linkedin-profiles-discover/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-easy_scraper-linkedin-profiles-discover",
                "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/easy_scraper~linkedin-profiles-discover/runs": {
            "post": {
                "operationId": "runs-sync-easy_scraper-linkedin-profiles-discover",
                "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/easy_scraper~linkedin-profiles-discover/run-sync": {
            "post": {
                "operationId": "run-sync-easy_scraper-linkedin-profiles-discover",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "🔍 Keywords — Use the target country's language for best results",
                        "minItems": 1,
                        "type": "array",
                        "description": "Keywords to discover LinkedIn profiles for. Tip: use native-language keywords for non-English countries (e.g. \"مدون سياحي\" for Arabic, \"旅行博主\" for Chinese, \"путешественник\" for Russian).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProfilesPerKeyword": {
                        "title": "📊 Max Profiles Per Keyword (per country)",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique Instagram profiles to collect per keyword per country. The on-demand queue stops fetching once this is reached — no wasted SERP requests.",
                        "default": 100
                    },
                    "countries": {
                        "title": "🌍 Target Countries — match keywords to country language for best results",
                        "type": "array",
                        "description": "Select target countries. Each uses its own Google domain and proxy. US uses state names as modifiers. Non-Latin countries (AR, HI, ZH, JA, KO, etc.) use native script characters. ⚠️ For non-English countries enter keywords in the local language.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "US",
                                "IN",
                                "CN",
                                "BR",
                                "ID",
                                "PK",
                                "NG",
                                "BD",
                                "RU",
                                "MX",
                                "ET",
                                "JP",
                                "PH",
                                "EG",
                                "VN",
                                "TR",
                                "IR",
                                "DE",
                                "TH",
                                "GB",
                                "FR",
                                "IT",
                                "CA",
                                "KR",
                                "AU",
                                "ES",
                                "SA",
                                "AE",
                                "NL"
                            ],
                            "enumTitles": [
                                "US",
                                "IN",
                                "CN",
                                "BR",
                                "ID",
                                "PK",
                                "NG",
                                "BD",
                                "RU",
                                "MX",
                                "ET",
                                "JP",
                                "PH",
                                "EG",
                                "VN",
                                "TR",
                                "IR",
                                "DE",
                                "TH",
                                "GB",
                                "FR",
                                "IT",
                                "CA",
                                "KR",
                                "AU",
                                "ES",
                                "SA",
                                "AE",
                                "NL"
                            ]
                        },
                        "default": [
                            "US"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```