# LinkedIn Company Scraper - No Login, No Cookies (`logiover/linkedin-company-scraper`) Actor

Scrape LinkedIn company firmographics without login or cookies. Export company data to CSV/JSON - headcount, industry, HQ, followers, website & logo.

- **URL**: https://apify.com/logiover/linkedin-company-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.50 / 1,000 results

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

<h1 align="center">🏢 LinkedIn Company Scraper — No Login, No Cookies</h1>
<h3 align="center">Scrape public LinkedIn company data (firmographics) — <em>no login, no cookies, no API key, zero account-ban risk.</em></h3>

<p align="center">
  <img alt="No login" src="https://img.shields.io/badge/Login-NOT%20required-2ecc71?style=for-the-badge&logo=linkedin&logoColor=white">
  <img alt="No cookies" src="https://img.shields.io/badge/Cookies-NONE-2ecc71?style=for-the-badge">
  <img alt="Ban risk" src="https://img.shields.io/badge/Account%20ban%20risk-ZERO-2ecc71?style=for-the-badge">
  <img alt="Engine" src="https://img.shields.io/badge/Engine-Pure%20HTTP%20(fast)-0a66c2?style=for-the-badge">
  <img alt="Pricing" src="https://img.shields.io/badge/Pricing-Pay%20per%20result-9b59b6?style=for-the-badge">
</p>

<p align="center">
  <b>Drop in a list of companies → get back a clean, structured firmographics dataset.</b><br>
  <code>industry</code> · <code>exact headcount</code> · <code>size band</code> · <code>followers</code> · <code>HQ</code> · <code>specialties</code> · <code>website</code> · <code>logo</code> · <code>recent posts</code>
</p>

<p align="center"><sub>✅ JSON · CSV · Excel · HTML · API &nbsp;|&nbsp; ✅ Works out of the box &nbsp;|&nbsp; ✅ Scales to thousands of companies per run</sub></p>

---

### 😣 The problem with every other LinkedIn scraper

Most LinkedIn scrapers ask you to paste your **session cookie** (`li_at`) or log in with your account. The moment you scrape at any real volume, LinkedIn flags that session and **bans the account — often within 3–7 days.** You lose your network, your history, and your tool breaks the next time LinkedIn rotates its tokens.

### 😎 How this one is different

This actor reads **only the public company page** LinkedIn already serves to logged-out visitors. **No login. No cookie. No account in the loop — so there is nothing to flag and nothing to ban.** It's pure HTTP (no slow headless browser), so it's fast, cheap, and doesn't break every other week.

> **You keep your LinkedIn account. You keep your data. You only pay for results you actually get.**

---

### ⚖️ This actor vs. cookie / login scrapers

| | 🏢 **LinkedIn Company Scraper** | 🍪 Cookie / login scrapers |
|---|:---:|:---:|
| LinkedIn login required | **❌ Never** | ✅ Yes |
| Session cookie (`li_at`) required | **❌ Never** | ✅ Yes |
| Risk of an account getting **banned** | **🟢 Zero** | 🔴 High (3–7 days) |
| Breaks when LinkedIn rotates tokens | **🟢 No** | 🔴 Constantly |
| Engine | **⚡ Pure HTTP** | 🐢 Headless browser |
| Input flexibility | **URL · slug · name** | URL only |
| Recent company posts included | **✅ Yes** | ⚠️ Rarely |
| Setup before first run | **🟢 None** | 🔴 Cookie export, proxies |
| Billing | **✅ Pay per result** | varies |

---

### 👀 See the output before you spend a cent

A single run on `["google", "stripe", "apify"]` returns rows like this:

```json
{
  "name": "Google",
  "industry": "Software Development",
  "employeeCount": 303613,
  "companySizeRange": "10,001+ employees",
  "followerCount": 41759491,
  "founded": null,
  "specialties": ["search", "ads", "machine learning", "cloud", "artificial intelligence"],
  "headquarters": "Mountain View, CA",
  "address": { "street": "1600 Amphitheatre Parkway", "city": "Mountain View", "region": "CA", "postalCode": "94043", "country": "US" },
  "website": "https://goo.gle/3DLEokh",
  "logoUrl": "https://media.licdn.com/dms/image/.../google_logo",
  "companyId": "1441",
  "companySlug": "google",
  "linkedinUrl": "https://www.linkedin.com/company/google",
  "recentPosts": [{ "text": "For this year's Google I/O…", "url": "https://www.linkedin.com/posts/google_…", "datePublished": "2026-06-02T21:42:08Z" }],
  "scrapedAt": "2026-06-03T10:00:00.000Z"
}
````

*Real fields from a real run — nothing mocked.*

***

### 🚀 Get your first dataset in 30 seconds

1. Open the **Input** tab.
2. Paste companies into **Companies** — any mix works:
   - Full URL → `https://www.linkedin.com/company/stripe/`
   - Slug → `stripe`
   - Name → `Stripe` *(auto-slugified; use the exact URL/slug when you need guaranteed precision)*
3. Hit **Start**. Watch rows stream into your dataset, then export to **JSON / CSV / Excel / HTML** or pull from the **API**.

No browser extension. No proxy setup. No scraping your own account. It just runs.

***

### 📦 Every field you get

| Field | Type | Example |
|---|---|---|
| `name` | string | `"Google"` |
| `description` | string | `"A problem isn't truly solved until…"` |
| `industry` | string | `"Software Development"` |
| `employeeCount` | number | `303613` |
| `companySizeRange` | string | `"10,001+ employees"` |
| `followerCount` | number | `41759491` |
| `founded` | string | `"2010"` |
| `specialties` | string\[] | `["search","ads","cloud",…]` |
| `headquarters` | string | `"Mountain View, CA"` |
| `address` | object | `{ street, city, region, postalCode, country }` |
| `website` | string | `"https://goo.gle/3DLEokh"` |
| `logoUrl` | string | `"https://media.licdn.com/…"` |
| `companyId` | string | `"1441"` |
| `companySlug` | string | `"google"` |
| `linkedinUrl` | string | `"https://www.linkedin.com/company/google"` |
| `recentPosts` | array | `[{ text, url, datePublished }]` |
| `scrapedAt` | string | ISO timestamp |

***

### 💰 What teams use it for (and the ROI)

- **🎯 Sales & ABM enrichment** — turn a target-account list into firmographics (size, industry, HQ, headcount) for lead scoring and territory planning. One run can replace hours of manual LinkedIn lookups.
- **🧭 Market & competitor mapping** — profile every company in a category and compare headcount, growth signals, and specialties side by side.
- **🗂️ CRM hygiene** — refresh stale records in HubSpot / Salesforce / Pipedrive with current employee counts and follower numbers on a schedule.
- **📈 Investment & M\&A scouting** — build watchlists of companies in a vertical with structured, comparable data instead of screenshots.
- **🤝 Recruiting intelligence** — size up target employers, track their growth, prioritise outreach.
- **🧱 Data products & AI** — assemble a clean company-firmographics corpus for your own app, model, or RAG pipeline.

***

### 🛡️ Built to be reliable

- **Pure-HTTP engine** with automatic session rotation and smart retries — when LinkedIn throttles a session, the actor quietly retries on a fresh one instead of failing your row.
- **Apify Proxy** built in. The default (datacenter / automatic) is the cheapest and works for most lists; switch to **RESIDENTIAL** for very large runs.
- **Graceful failures** — a wrong slug or removed page returns a clear `error` field instead of crashing the whole run, so a 5,000-company job always finishes.

***

### ⚙️ Input options

| Option | Default | What it does |
|---|---|---|
| `companies` | – | **Required.** Array of company URLs, slugs, or names. |
| `includeRecentPosts` | `true` | Capture the company's most recent public posts. |
| `maxConcurrency` | `8` | How many companies to fetch in parallel. |
| `proxyConfiguration` | Apify Proxy (auto) | Proxy routing. RESIDENTIAL recommended for huge lists. |

***

### ❓ FAQ

#### Does this LinkedIn company scraper need a login or cookie?

No — and that's the whole point. It only reads the public company page LinkedIn serves to logged-out visitors. No login, no `li_at` session cookie, no API key. Your account is never used, so it can't be flagged, throttled, or banned.

#### Is scraping LinkedIn company data legal?

It collects only **publicly visible** company information — the same data anyone sees without logging in. The *hiQ Labs v. LinkedIn* line of cases supports access to public data in the US. You're responsible for using the output in line with LinkedIn's terms and applicable laws (GDPR/CCPA) in your region. This tool does not collect private or login-gated data.

#### How do I export LinkedIn company data to CSV or Excel?

Every run streams into an Apify dataset you can export to **CSV, JSON, Excel, HTML or XML**, or pull live via the API and webhooks. No copy-paste, no manual cleanup.

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

As many as you want — feed a list of any size and results stream straight into your dataset. You only pay per result, so a 5,000-company job is predictable and finishes cleanly.

#### Can I get the full employee list of a company?

LinkedIn hides the employee directory from logged-out visitors (that's the part that requires a risky logged-in session), so it's intentionally out of scope. This actor focuses on the rich, public **company-level** firmographics — the data that's both valuable *and* safe to collect. For people data, pair it with the **LinkedIn Profile Scraper**.

#### A company came back with an `error` field — why?

The slug was wrong, the page is private/removed, or it was throttled after all retries. Re-run those items, ideally with RESIDENTIAL proxy.

#### Is this a LinkedIn company API alternative?

Yes — it's a no-login LinkedIn company data extraction tool that works without an official API key. You feed company URLs, slugs, or names and get structured firmographics back, no LinkedIn API access or app review needed.

#### How do I export LinkedIn company firmographics to CSV or JSON?

Every run streams into an Apify dataset, so you can export LinkedIn company data to CSV, JSON, Excel, HTML, or XML in one click — or pull it live via API and webhooks. It's a clean LinkedIn firmographics export with no manual cleanup.

#### Can I scrape LinkedIn companies without login or cookies?

Yes — this is a LinkedIn company scraper without login. It reads only the public company page LinkedIn serves to logged-out visitors, so there's no `li_at` cookie, no account in the loop, and no ban risk.

***

<p align="center">👤 <b>Need people data too?</b> Pair this with the <b>LinkedIn Profile Scraper</b> — every <code>recentPosts</code> author and company link flows straight into it.</p>

<p align="center"><sub>Not affiliated with, endorsed by, or sponsored by LinkedIn. "LinkedIn" is a trademark of LinkedIn Corporation. This tool accesses only publicly available data. Use responsibly and in compliance with applicable law.</sub></p>

### 📝 Changelog

#### 2026-06-07

- Docs: added coverage for LinkedIn company API alternative, exporting firmographics to CSV/JSON, and scraping companies without login or cookies.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

# Actor input Schema

## `companies` (type: `array`):

List of companies to scrape. Each item can be a full LinkedIn company URL (`https://www.linkedin.com/company/google/`), a bare slug (`google`), or a company name (`Google`). Names are auto-converted to slugs (works best for well-known brands; use the exact URL/slug for precision).

## `includeRecentPosts` (type: `boolean`):

Also capture the company's most recent public posts (text, URL, date) that LinkedIn embeds on the page. Turn off for a leaner, company-profile-only output.

## `maxConcurrency` (type: `integer`):

How many companies to fetch in parallel. Lower values are gentler and more reliable; raise it for big lists on residential proxies.

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

Apify Proxy is recommended. The default (datacenter / automatic) is cheapest and works for most runs; switch to RESIDENTIAL for very large lists or if you start seeing throttling.

## Actor input object example

```json
{
  "companies": [
    "https://www.linkedin.com/company/google/",
    "stripe",
    "Anthropic"
  ],
  "includeRecentPosts": true,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `name` (type: `string`):

Company name

## `industry` (type: `string`):

Primary industry

## `employeeCount` (type: `string`):

Exact employee count

## `companySizeRange` (type: `string`):

Company size band

## `followerCount` (type: `string`):

LinkedIn follower count

## `headquarters` (type: `string`):

Headquarters location

## `website` (type: `string`):

Company website

## `linkedinUrl` (type: `string`):

Company LinkedIn page

# 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 = {
    "companies": [
        "https://www.linkedin.com/company/google/",
        "microsoft",
        "https://www.linkedin.com/company/stripe/",
        "openai",
        "https://www.linkedin.com/company/apify/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/linkedin-company-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 = {
    "companies": [
        "https://www.linkedin.com/company/google/",
        "microsoft",
        "https://www.linkedin.com/company/stripe/",
        "openai",
        "https://www.linkedin.com/company/apify/",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/linkedin-company-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 '{
  "companies": [
    "https://www.linkedin.com/company/google/",
    "microsoft",
    "https://www.linkedin.com/company/stripe/",
    "openai",
    "https://www.linkedin.com/company/apify/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call logiover/linkedin-company-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Scraper - No Login, No Cookies",
        "description": "Scrape LinkedIn company firmographics without login or cookies. Export company data to CSV/JSON - headcount, industry, HQ, followers, website & logo.",
        "version": "0.0",
        "x-build-id": "aWcWO1FjHhrsa7A25"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~linkedin-company-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-linkedin-company-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/logiover~linkedin-company-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-linkedin-company-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/logiover~linkedin-company-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-linkedin-company-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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies (URLs, slugs, or names)",
                        "type": "array",
                        "description": "List of companies to scrape. Each item can be a full LinkedIn company URL (`https://www.linkedin.com/company/google/`), a bare slug (`google`), or a company name (`Google`). Names are auto-converted to slugs (works best for well-known brands; use the exact URL/slug for precision).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeRecentPosts": {
                        "title": "Include recent posts",
                        "type": "boolean",
                        "description": "Also capture the company's most recent public posts (text, URL, date) that LinkedIn embeds on the page. Turn off for a leaner, company-profile-only output.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many companies to fetch in parallel. Lower values are gentler and more reliable; raise it for big lists on residential proxies.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is recommended. The default (datacenter / automatic) is cheapest and works for most runs; switch to RESIDENTIAL for very large lists or if you start seeing throttling.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
