# LinkedIn Profile Posts Scraper (`automation-lab/linkedin-profile-posts-scraper`) Actor

Extract recent public LinkedIn profile posts and articles from known profiles or post URLs. No customer cookies required.

- **URL**: https://apify.com/automation-lab/linkedin-profile-posts-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Profile Posts Scraper

Extract recent public posts from LinkedIn profile activity pages and individual LinkedIn post URLs without asking users for account cookies.

### What does LinkedIn Profile Posts Scraper do?

LinkedIn Profile Posts Scraper turns a list of public LinkedIn profile URLs or slugs into a clean dataset of recent public posts.

It is designed for repeat workflows where you already know the people you want to monitor.

The actor visits public LinkedIn profile activity pages, reads structured public page data, and saves one dataset item per post.

It can also accept individual LinkedIn post URLs when your workflow starts from a saved link.

### Who is it for?

- 💼 Sales teams tracking buying signals from target accounts and executives.
- 🧲 Recruiters monitoring public thought leadership from candidate pools.
- 📣 Founder, analyst, and influencer monitoring teams.
- 🕵️ Competitive intelligence teams following public LinkedIn narratives.
- 🤖 Automation builders who need LinkedIn posts in a dataset, API, or webhook.

### Why use this actor?

- No customer LinkedIn cookies are required.
- Outputs structured rows instead of screenshots or page HTML.
- Supports profile slugs, full profile URLs, activity URLs, and post URLs.
- Uses conservative retries and proxy sessions for public LinkedIn pages.
- Works well in recurring Apify tasks for monitoring known profiles.

### What LinkedIn data can it extract?

The actor extracts public post metadata that LinkedIn exposes on reachable public pages.

| Field | Description |
| --- | --- |
| `profileName` | Public profile name when available |
| `profileSlug` | LinkedIn profile slug |
| `profileUrl` | Normalized profile URL |
| `postUrl` | Canonical post or article URL |
| `postUrn` | Activity URN when present in the URL |
| `postType` | JSON-LD item type such as Article |
| `text` | Public post text when available |
| `headline` | Headline or title |
| `datePublished` | Published timestamp |
| `dateModified` | Modified timestamp when available |
| `authorName` | Author name |
| `imageUrl` | Public image URL when available |
| `likeCount` | Public like/reaction count when available |
| `commentCount` | Public comment count when available |
| `sourceUrl` | Input URL that produced the row |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape LinkedIn profile posts?

The actor uses pay-per-event pricing.

There is a small start fee per run and a per-post fee for each saved dataset item.

Small test runs are inexpensive because you can set `maxItems` and `maxPostsPerProfile` to low values.

For recurring monitoring, schedule smaller batches instead of one huge run if you need predictable spend.

### Quick start

1. Open the actor on Apify.
2. Add one or more LinkedIn profile URLs or slugs.
3. Set `maxPostsPerProfile`.
4. Set `maxItems` for a global safety cap.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Input examples

Use a public profile activity URL:

```json
{
  "profileUrls": ["https://www.linkedin.com/in/satyanadella/recent-activity/all/"],
  "maxPostsPerProfile": 10,
  "maxItems": 10,
  "proxyCountryCode": "US"
}
````

Use profile slugs:

```json
{
  "profileUrls": ["satyanadella", "garyvaynerchuk", "simonsinek"],
  "maxPostsPerProfile": 10,
  "maxItems": 30
}
```

Use individual post URLs:

```json
{
  "profileUrls": [],
  "postUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:1234567890/"],
  "maxItems": 1
}
```

### Input fields

#### `profileUrls`

Array of LinkedIn profile URLs, profile activity URLs, or slugs.

The actor normalizes each entry to the public recent activity page.

#### `postUrls`

Optional array of individual LinkedIn post URLs.

Use this when your system already captured post links.

#### `maxPostsPerProfile`

Maximum posts saved from each profile.

Start with 5-10 for testing.

#### `maxItems`

Global maximum number of rows saved by the run.

This protects budgets when you provide many sources.

#### `proxyCountryCode`

Residential proxy country code.

`US` is the safest default for public LinkedIn pages.

### Output example

```json
{
  "profileName": "Satya Nadella",
  "profileSlug": "satyanadella",
  "profileUrl": "https://www.linkedin.com/in/satyanadella/",
  "postUrl": "https://www.linkedin.com/pulse/how-do-we-build-frontier-intelligence-ecosystem-satya-nadella-73jhc",
  "postType": "Article",
  "headline": "How do we build a frontier intelligence ecosystem?",
  "datePublished": "2026-06-02T19:41:31.000+00:00",
  "authorName": "Satya Nadella",
  "likeCount": 2531,
  "sourceUrl": "https://www.linkedin.com/in/satyanadella/recent-activity/all/",
  "scrapedAt": "2026-07-07T05:30:58.959Z"
}
```

### Tips for reliable runs

- Prefer public profile activity URLs when you have them.
- Use known public creator or executive profiles.
- Keep `maxPostsPerProfile` modest for recurring monitoring.
- Split very large watchlists into multiple scheduled tasks.
- Expect some profiles to be unavailable or blocked by LinkedIn.
- Re-run later if a profile returns a temporary LinkedIn `999` or `429` response.

### Common workflows

#### Sales trigger monitoring

Monitor public posts from target executives and route new rows to a CRM or Slack.

#### Recruiting intelligence

Track public posts from candidates, hiring managers, or talent communities.

#### Influencer tracking

Build a recurring dataset of public LinkedIn posts by industry voices.

#### Founder and investor watchlists

Follow public posts from founders, investors, and operators relevant to a thesis.

### Integrations

Use Apify integrations to send results to:

- Google Sheets for analyst review.
- Make or Zapier for CRM enrichment.
- Slack for public-post alerts.
- Webhooks for custom monitoring systems.
- Dataset API consumers in Python, Node.js, or BI tools.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/linkedin-profile-posts-scraper').call({
  profileUrls: ['satyanadella'],
  maxPostsPerProfile: 10,
  maxItems: 10,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/linkedin-profile-posts-scraper').call(run_input={
    'profileUrls': ['satyanadella'],
    'maxPostsPerProfile': 10,
    'maxItems': 10,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~linkedin-profile-posts-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"profileUrls":["satyanadella"],"maxPostsPerProfile":10,"maxItems":10}'
```

### MCP usage

Connect Apify MCP at:

`https://mcp.apify.com/?tools=automation-lab/linkedin-profile-posts-scraper`

Claude Code setup:

```bash
claude mcp add apify-linkedin-profile-posts https://mcp.apify.com/?tools=automation-lab/linkedin-profile-posts-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Run the LinkedIn Profile Posts Scraper for these five founder profiles."
- "Export the latest dataset rows as a summary of public buying signals."
- "Create a weekly task that monitors these LinkedIn profiles for new posts."

### Scheduling

Create an Apify task with your profile watchlist.

Set a weekly or daily schedule depending on how often you need updates.

Use `maxItems` to control spend for each scheduled run.

### Data quality notes

LinkedIn changes public page markup and access controls frequently.

Some rows may have a headline but no full text.

Some rows may have like counts but no comment counts.

Unavailable profiles are skipped so one blocked source does not fail the whole run.

### FAQ and troubleshooting

#### Why did a profile return zero posts?

The profile may not expose public recent activity, LinkedIn may have returned a temporary block page, or the profile may require login.

Try another public profile, reduce batch size, or rerun later.

#### Why are some fields null?

The actor only returns values that are publicly present in LinkedIn structured page data.

Null values are expected when LinkedIn hides a metric or text field.

#### Do I need LinkedIn cookies?

No. This actor is designed for public, no-cookie extraction.

### Legality and privacy

This actor extracts public web data only.

Do not use it to collect private LinkedIn account data, bypass access controls, or violate LinkedIn terms or applicable law.

You are responsible for ensuring your use case complies with local rules and platform policies.

### Related scrapers

- https://apify.com/automation-lab/linkedin-profile-scraper
- https://apify.com/automation-lab/linkedin-company-posts-scraper
- https://apify.com/automation-lab/linkedin-post-scraper
- https://apify.com/automation-lab/linkedin-post-comments-reactions-scraper

### Changelog

#### 0.1

Initial private build for public LinkedIn profile post extraction.

### Support

If a run fails, include the run ID, input JSON, and expected public profile URL when requesting help.

# Actor input Schema

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

Public LinkedIn profile URLs, /recent-activity/all/ URLs, or simple profile slugs. Example: satyanadella or https://www.linkedin.com/in/satyanadella/

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

Optional LinkedIn feed/update URLs to extract directly. These are processed in addition to profile URLs.

## `maxPostsPerProfile` (type: `integer`):

Maximum number of posts to save from each profile activity page.

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

Global maximum number of dataset items to emit across all sources.

## `proxyCountryCode` (type: `string`):

Residential proxy country used for LinkedIn requests. US is the safest default for public LinkedIn pages.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/recent-activity/all/"
  ],
  "postUrls": [],
  "maxPostsPerProfile": 10,
  "maxItems": 20,
  "proxyCountryCode": "US"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella/recent-activity/all/"
    ],
    "postUrls": [],
    "maxPostsPerProfile": 10,
    "maxItems": 20,
    "proxyCountryCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/linkedin-profile-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 = {
    "profileUrls": ["https://www.linkedin.com/in/satyanadella/recent-activity/all/"],
    "postUrls": [],
    "maxPostsPerProfile": 10,
    "maxItems": 20,
    "proxyCountryCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/linkedin-profile-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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/recent-activity/all/"
  ],
  "postUrls": [],
  "maxPostsPerProfile": 10,
  "maxItems": 20,
  "proxyCountryCode": "US"
}' |
apify call automation-lab/linkedin-profile-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Posts Scraper",
        "description": "Extract recent public LinkedIn profile posts and articles from known profiles or post URLs. No customer cookies required.",
        "version": "0.1",
        "x-build-id": "AW1kOC7Nf6bQqnewQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~linkedin-profile-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-linkedin-profile-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/automation-lab~linkedin-profile-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-linkedin-profile-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/automation-lab~linkedin-profile-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-linkedin-profile-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",
                "required": [
                    "profileUrls"
                ],
                "properties": {
                    "profileUrls": {
                        "title": "Profile URLs or slugs",
                        "type": "array",
                        "description": "Public LinkedIn profile URLs, /recent-activity/all/ URLs, or simple profile slugs. Example: satyanadella or https://www.linkedin.com/in/satyanadella/",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Individual post URLs",
                        "type": "array",
                        "description": "Optional LinkedIn feed/update URLs to extract directly. These are processed in addition to profile URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerProfile": {
                        "title": "Maximum posts per profile",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of posts to save from each profile activity page.",
                        "default": 25
                    },
                    "maxItems": {
                        "title": "Maximum total posts",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Global maximum number of dataset items to emit across all sources.",
                        "default": 20
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "NL"
                        ],
                        "type": "string",
                        "description": "Residential proxy country used for LinkedIn requests. US is the safest default for public LinkedIn pages.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```