# Linkedin Posts Scraper (`silentflow/linkedin-posts-scraper`) Actor

Extract LinkedIn posts at scale – no login, no cookies, no maintenance. Search keywords, scrape company pages or profile posts instantly. Get full post text, likes, comments, author details & images. Anti-detection built-in with residential proxies. Fast, reliable, enterprise-ready.

- **URL**: https://apify.com/silentflow/linkedin-posts-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 30 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

$24.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Post Scraper - No Login Required

Scrape LinkedIn posts **without cookies or login**. Extract post content, author info, engagement metrics, and more. Unleash the power of LinkedIn data! 🌐🔍

### 🌟 Features

- 🔓 **No Authentication**: Works without LinkedIn cookies or login
- 🔍 **Multi Search Option**: Search by keywords, post URLs, or profile/company URLs
- 📈 **Engagement Metrics**: Get likes, comments, shares, and more
- 👤 **Author Details**: Full author info including name, headline, profile URL
- ⚡ **Zero Maintenance**: No cookies to expire, auto user-agent rotation
- 🎯 **~100% Success Rate**: Advanced TLS fingerprinting and browser rotation

### 💡 Use Cases

- 📊 **Content Analysts**: Analyze trending topics and viral posts
- 💼 **Marketers**: Monitor brand mentions and competitor content
- 🎯 **Sales Teams**: Find engaging content from prospects
- 🔬 **Researchers**: Gather social media data for studies
- 📰 **News Aggregators**: Track industry announcements

### 🚀 How to Use

#### Search by Keywords (Most Common)
```json
{
  "keywords": ["artificial intelligence", "machine learning"],
  "dateFilter": "past-week",
  "limit": 20,
  "fetchDetails": true
}
````

#### Scrape Specific Posts

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/openai_the-openai-podcast-activity-7468347768948936704-yw3W"
  ],
  "fetchDetails": true
}
```

#### Get Posts from Profile/Company

```json
{
  "profileUrls": [
    "https://www.linkedin.com/company/openai",
    "https://www.linkedin.com/in/satyanadella"
  ],
  "limit": 10,
  "fetchDetails": true
}
```

### ⚙️ Input Parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `keywords` | Array | Search terms (e.g., `["AI", "startup"]`) | `[]` |
| `postUrls` | Array | Direct LinkedIn post URLs | `[]` |
| `profileUrls` | Array | Profile or company URLs to get posts from | `[]` |
| `dateFilter` | Enum | `past-24h`, `past-week`, `past-month` | None |
| `limit` | Integer | Max posts per keyword/profile (1-100) | `10` |
| `fetchDetails` | Boolean | Get full details from LinkedIn (slower, more data) | `false` |
| `proxy` | Object | Proxy configuration | Apify Residential |

### 📤 Output Format

```json
{
  "postId": "openai_the-openai-podcast-activity-7468347768948936704-yw3W",
  "url": "https://www.linkedin.com/posts/openai_the-openai-podcast-activity-7468347768948936704-yw3W",
  "text": "Last month AI found something mathematicians had missed for decades. Reasoning researchers join the podcast to discuss how...",
  "type": "text",
  "postedAt": "2026-06-04T17:07:43.292Z",
  "authorName": "OpenAI",
  "authorProfileUrl": "https://www.linkedin.com/company/openai",
  "authorProfileId": "openai",
  "authorImage": "https://media.licdn.com/...",
  "numLikes": 221,
  "numComments": 51,
  "numShares": 0,
  "images": ["https://media.licdn.com/..."],
  "hashtags": [],
  "isRepost": false,
  "isSponsored": false,
  "scrapedAt": "2024-01-15T10:30:00Z"
}
```

#### Output Field Reference

| Field | Type | Always Present | Notes |
|-------|------|----------------|-------|
| `postId` | string | ✅ | Unique post identifier |
| `url` | string | ✅ | Full LinkedIn post URL |
| `text` | string | ✅ | Post content (may be truncated in Quick mode) |
| `type` | string | ✅ | `text`, `image`, or `video` |
| `authorName` | string | ✅ | Author display name |
| `authorProfileUrl` | string | ✅ | Author's LinkedIn profile URL |
| `authorProfileId` | string | ✅ | Author's LinkedIn ID |
| `authorImage` | string | ⚠️ | Author avatar URL (may be null) |
| `authorHeadline` | string | ❌ | Rarely available |
| `postedAt` | string | ⚠️ | ISO date (requires fetchDetails) |
| `numLikes` | number | ⚠️ | 0 = no likes OR not fetched |
| `numComments` | number | ⚠️ | 0 = no comments OR not fetched |
| `numShares` | number | ⚠️ | Usually 0 (LinkedIn hides this) |
| `images` | array | ✅ | Empty array if no images |
| `hashtags` | array | ✅ | Empty array if no hashtags |
| `isRepost` | boolean | ✅ | Whether post is a repost |
| `isSponsored` | boolean | ✅ | Whether post is sponsored |
| `scrapedAt` | string | ✅ | When data was scraped |

### 📊 Data Availability by Mode

| Data | Quick Mode | Quick + fetchDetails | Post URL Mode |
|------|------------|---------------------|---------------|
| Post URL | ✅ | ✅ | ✅ |
| Text Preview | ✅ | ✅ | ✅ |
| Full Text | ❌ | ✅ | ✅ |
| Author Name | ⚠️ From ID | ✅ | ✅ |
| Author Headline | ❌ | ⚠️ Rare | ⚠️ Rare |
| Author Image | ❌ | ✅ | ✅ |
| Likes Count | ❌ | ✅ | ✅ |
| Comments Count | ❌ | ✅ | ✅ |
| Posted Date | ⚠️ Partial | ✅ | ✅ |
| Hashtags | ❌ | ✅ | ✅ |
| Images | ❌ | ✅ | ✅ |

> ⚠️ **Note**: Some posts may be private or deleted. Use `fetchDetails: true` for best data quality.

### ⚡ Speed vs Data

| Mode | Speed | Data |
|------|-------|------|
| `fetchDetails: false` | ~150 posts/min | Basic (URL, text preview) |
| `fetchDetails: true` | ~30-80 posts/min | Full (all 18+ fields) |

**Recommendation**: Use `fetchDetails: true` for best results.

### ⚠️ Limitations

- **Profile Mode**: Works best for **company pages** (OpenAI, Google, Microsoft). Personal profiles have limited indexing - use keywords search instead.
- **Private Posts**: Cannot access private or connection-only posts
- **Rate Limiting**: Very large scrapes (1000+ posts) may experience rate limiting

### 💡 Tips for Best Results

1. **Use Residential Proxies**: Essential for reliable results
2. **Enable fetchDetails**: Gets complete post information
3. **Use dateFilter**: Get recent posts only
4. **Start Small**: Test with `limit: 5` before scaling up
5. **Be Specific**: More precise keywords = better results
6. **For Personal Profiles**: Use keywords search with the person's name instead of profileUrls

### 🔧 Troubleshooting

#### Common Issues & Solutions

| Issue | Cause | Solution |
|-------|-------|----------|
| **No posts found** | Profile not indexed or private | Try keywords search with the person/company name |
| **Timeout errors** | Large request or slow network | Reduce `limit`, enable `fetchDetails: true` |
| **Rate limited** | Too many requests | Wait a few minutes, use residential proxies |
| **Missing fields** | `fetchDetails: false` | Set `fetchDetails: true` for full data |
| **Invalid URL error** | Malformed LinkedIn URL | Use full URL: `https://www.linkedin.com/posts/...` |

#### Understanding Empty Results

- **Profile mode returns 0 posts**: The profile may not have public posts indexed by search engines. Try `keywords` search with the person's name instead.
- **Keywords return 0 posts**: The search term may be too specific. Try broader keywords.
- **Some posts missing data**: LinkedIn pages may not include all metadata. This is normal.

#### Field Availability Notes

| Field | Notes |
|-------|-------|
| `numLikes = 0` | Could mean no likes OR data not available |
| `authorHeadline` | Often empty - LinkedIn doesn't always expose this |
| `hashtags = []` | Post may not have hashtags |
| `images = []` | Post is text-only |

#### When to Use Each Mode

```
Keywords Mode    → Best for: Topic research, trending content
Post URL Mode    → Best for: Specific posts you already know
Profile Mode     → Best for: Company pages (OpenAI, Google, etc.)
```

#### Error Messages Explained

- `timeout after 90s` → Request took too long. Reduce batch size.
- `rate limited` → Too many requests. Wait and retry with proxies.
- `not found (404)` → Post deleted or private.
- `network error` → Connection issue. Check proxy settings.

### 📞 Support

Having issues? Check the Issues tab or contact support.

***

Made by **SilentFlow**

# Actor input Schema

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

Keywords to search for in LinkedIn posts (e.g. 'AI', 'startup funding', 'remote work'). Each keyword will trigger a separate search.

## `postUrls` (type: `array`):

Direct LinkedIn post URLs to scrape. Supports both /posts/ and /feed/update/ formats.

## `profileUrls` (type: `array`):

LinkedIn profile or company URLs to get posts from. Will search for posts by these authors.

## `dateFilter` (type: `string`):

Filter posts by date

## `limit` (type: `integer`):

Maximum number of posts to return per keyword or profile

## `fetchDetails` (type: `boolean`):

Enable to fetch complete post details from LinkedIn (slower but more data). Disable for faster basic scraping.

## `proxy` (type: `object`):

Select proxies to be used. Residential proxies recommended for best results.

## Actor input object example

```json
{
  "keywords": [
    "AI"
  ],
  "postUrls": [],
  "profileUrls": [],
  "dateFilter": "",
  "limit": 10,
  "fetchDetails": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `posts` (type: `string`):

Complete post data including: authorName, authorHeadline, authorProfileUrl, authorProfileId, text (post content), url, numLikes, numComments, numShares, postedAtISO, type (post/article/video), images, video, hashtags, mentions.

## `postsCSV` (type: `string`):

CSV format export of all posts for spreadsheet analysis

## `postsExcel` (type: `string`):

Excel format export of all posts

# 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": [
        "AI"
    ],
    "postUrls": [],
    "profileUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/linkedin-posts-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": ["AI"],
    "postUrls": [],
    "profileUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/linkedin-posts-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": [
    "AI"
  ],
  "postUrls": [],
  "profileUrls": []
}' |
apify call silentflow/linkedin-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Posts Scraper",
        "description": "Extract LinkedIn posts at scale – no login, no cookies, no maintenance. Search keywords, scrape company pages or profile posts instantly. Get full post text, likes, comments, author details & images. Anti-detection built-in with residential proxies. Fast, reliable, enterprise-ready.",
        "version": "1.0",
        "x-build-id": "vL2nYRqwSPGW6XEoH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~linkedin-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-linkedin-posts-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/silentflow~linkedin-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-linkedin-posts-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/silentflow~linkedin-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-linkedin-posts-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": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search for in LinkedIn posts (e.g. 'AI', 'startup funding', 'remote work'). Each keyword will trigger a separate search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Direct LinkedIn post URLs to scrape. Supports both /posts/ and /feed/update/ formats.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileUrls": {
                        "title": "Profile/Company URLs",
                        "type": "array",
                        "description": "LinkedIn profile or company URLs to get posts from. Will search for posts by these authors.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFilter": {
                        "title": "Date Filter",
                        "enum": [
                            "",
                            "past-24h",
                            "past-week",
                            "past-month"
                        ],
                        "type": "string",
                        "description": "Filter posts by date",
                        "default": ""
                    },
                    "limit": {
                        "title": "Limit per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of posts to return per keyword or profile",
                        "default": 10
                    },
                    "fetchDetails": {
                        "title": "Fetch full details",
                        "type": "boolean",
                        "description": "Enable to fetch complete post details from LinkedIn (slower but more data). Disable for faster basic scraping.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used. Residential proxies recommended for best results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
