# Instagram Likes Scraper (`scrapepilotapi/instagram-likes-scraper`) Actor

👍 Instagram Likes Scraper (instagram-likes-scraper) collects usernames, profile IDs, and timestamps from public post likes — fast and accurate. 📊 Export CSV/JSON for engagement analysis, influencer vetting, competitor research, and growth. ⚡ Perfect for marketers & analysts.

- **URL**: https://apify.com/scrapepilotapi/instagram-likes-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.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

### Instagram Likes Scraper

The Instagram Likes Scraper is a purpose-built Instagram likes scraper that collects engaged users (likers + commenters) from public post URLs — fast and reliably. It solves the challenge of extracting who liked a post at scale by automating the Instagram likers list, making it easy to scrape Instagram post likes and export Instagram likes list data for analysis. Ideal for marketers, developers, data analysts, and researchers, this Instagram likers scraper enables engagement analysis, influencer vetting, and competitor research at scale.

### What data / output can you get?

Below are the exact fields pushed to the Apify dataset for each engaged user. You can export results as JSON or CSV from the Apify Console.

| Data field | Description | Example value |
| --- | --- | --- |
| full_name | Display name from user profile | "Jane Doe" |
| id | Stringified user identifier (pk/id) | "521847391" |
| username | Instagram handle | "janedoe" |
| is_private | Private account flag | false |
| is_verified | Verified badge flag | true |
| profile_pic_url | Profile image URL | "https://instagram.fxyz1-1.fna.fbcdn.net/v/t51.2885-19/..." |
| liked_post | Post URL associated with this engagement | "https://www.instagram.com/p/DLm63qQpxvw" |
| post_url | Same as liked_post (convenience) | "https://www.instagram.com/p/DLm63qQpxvw" |
| total_likes | Total like count reported by the API for that post | 1342 |
| latest_reel_media | Latest reel media timestamp (epoch seconds) or 0 | 0 |
| latest_reel_media_utc | Latest reel media timestamp (UTC) if provided; otherwise null | null |
| profile_pic_id | Profile picture ID if available; empty string otherwise | "" |
| is_new | API flag for “new” users if present; otherwise false | false |

Note: Each record is pushed live as it’s collected. Results are deduplicated by user id across likers and commenters. Export your dataset to JSON or CSV for downstream processing.

### Key features

- ⚡️ Smart proxy fallback
  Automatically attempts direct requests first, then falls back to datacenter and finally residential proxies if blocked — with clear [PROXY] logs. Ideal when you need an Instagram likes API alternative under real-world rate limits.

- 🧠 Engaged users (likers + commenters), deduplicated
  Combines Instagram likers with commenters for each post, deduplicates by user ID, and builds a unique Instagram likers list per run.

- 🛠️ Live saving to dataset
  Each user is pushed to the Apify dataset in real time so you can monitor progress and never lose partial results.

- 🔁 Built-in retry & rate-limit handling
  Robust retry logic with backoff for 429 responses and short, friendly delays keeps your Instagram likes data scraper stable.

- 📦 Structured output you can trust
  Consistent schema with fields like full_name, id, username, is_private, is_verified, profile_pic_url, liked_post, total_likes, and post_url.

- 🧰 Optional authenticated requests
  Provide an Instagram sessionid cookie via sessionId for authenticated requests; unauthenticated runs may be redirected to login and return 0 users.

- 📚 Bulk URL support
  Feed multiple post URLs in one run to scale your IG likes scraper tool for campaigns, audits, or research workflows.

- 📤 Easy export
  Export Instagram likes list data to JSON or CSV directly from the Apify Console.

### How to use Instagram Likes Scraper - step by step

1. Create or log in to your Apify account.
2. Open Apify Console → Actors and find “instagram-likes-scraper”.
3. Add your Instagram post URLs to startUrls (supports multiple URLs). Example format: "https://www.instagram.com/p/DLm63qQpxvw/".
4. (Optional) Set maxCount to cap the number of unique users (likers + commenters) to collect across all posts.
5. (Optional) Paste sessionId if you want authenticated requests. Without it, Instagram may return a login page and 0 users.
6. (Optional) Adjust proxyConfiguration (leave off for direct requests; the actor automatically falls back to datacenter and residential proxies if blocked).
7. Click Start. Monitor the Log for progress, retry events, and [PROXY] messages.
8. When finished (or even during the run), go to the OUTPUT tab to view, filter, and export your dataset as JSON or CSV.

Pro tip: If you need to scrape Instagram post likes repeatedly for analytics pipelines, schedule runs in Apify and fetch the dataset exports programmatically for downstream dashboards.

### Use cases

| Use case | Description |
| --- | --- |
| Influencer vetting & audience analysis | Analyze who liked a post to assess audience authenticity and fit before partnerships using an Instagram post likers extractor. |
| Competitor engagement tracking | Monitor and export Instagram likes list from competitors’ posts to profile engaged audiences over time. |
| Campaign performance reporting | Scrape Instagram post likes to enrich engagement reports with usernames and verification/private flags. |
| Community building | Download Instagram likers usernames to identify and reward highly engaged followers. |
| Academic & social research | Collect structured engagement data for studies into online communities and content diffusion. |
| CRM enrichment | Append likers’ usernames and basic profile metadata to your outreach lists for smarter segmentation. |
| Trend discovery | Use an Instagram likes scraping tool to spot verified users engaging with niche content. |

### Why choose Instagram Likes Scraper?

Built for precision and reliability, this Instagram likes crawler combines robust proxy fallback with clean, deduplicated engagement records.

- ✅ Accurate, structured output: Consistent fields for user and post engagement, ready for analysis.
- 🚀 Scales with bulk URLs: Run your Instagram likers list scraper across many posts in one job.
- 🛡️ Resilient to blocks: No proxy by default, with automatic fallback to datacenter then residential, plus retries and backoff.
- 🔎 Engagement-focused: Merges likers and commenters for a fuller view of who interacted with each post.
- 💾 Live data capture: Pushes each item to the dataset immediately, minimizing data loss risks.
- 🔐 Optional authentication: sessionId support when you need authenticated requests; clear logs if Instagram returns a login page.
- 💸 Export-ready: Download results as JSON or CSV for BI tools and spreadsheets.

In short, this Instagram likes data scraper delivers a stable Instagram likes API alternative without fragile browser automation or extensions.

### Is it legal / ethical to use Instagram Likes Scraper?

Yes — when done responsibly. This tool collects data from publicly available Instagram posts and endpoints. You should:

- Only scrape data from public posts you’re permitted to analyze.
- Respect Instagram’s terms and your local laws (e.g., GDPR, CCPA).
- Avoid spamming and misuse of personal data.
- Understand that private posts or authenticated-only content is not accessed unless you provide a valid sessionId.
- Consult your legal team for edge cases or commercial deployments.

### Input parameters & output format

#### Example input
```json
{
  "startUrls": [
    "https://www.instagram.com/p/DLm63qQpxvw/"
  ],
  "maxCount": 1000,
  "sessionId": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Parameters

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| startUrls | array | Yes | None | Paste one or more Instagram post URLs (e.g. https://www.instagram.com/p/XXXXX/). The actor collects likers + commenters from each. |
| maxCount | integer | No | 100 | Cap on unique users (likers + commenters) across all posts. Minimum 1, maximum 10,000. |
| sessionId | string | No | "" | Instagram sessionid cookie value for authenticated requests. Without it, requests may return 0 users (login page). |
| proxyConfiguration | object | No | None (prefill: {"useApifyProxy": false}) | Leave off for direct requests. If blocked, the actor auto-fallbacks to datacenter → residential proxies with retries. |

#### Example output (dataset items)

```json
{
  "full_name": "Jane Doe",
  "id": "521847391",
  "is_new": false,
  "is_private": false,
  "is_verified": true,
  "latest_reel_media": 0,
  "profile_pic_id": "",
  "profile_pic_url": "https://instagram.fxyz1-1.fna.fbcdn.net/v/t51.2885-19/...",
  "username": "janedoe",
  "liked_post": "https://www.instagram.com/p/DLm63qQpxvw",
  "total_likes": 1342,
  "latest_reel_media_utc": null,
  "post_url": "https://www.instagram.com/p/DLm63qQpxvw"
}
```

Notes:

- Each item represents a unique user who liked or commented on the post, deduplicated by id.
- Some optional fields (e.g., latest\_reel\_media\_utc, profile\_pic\_id) may be null or empty depending on Instagram’s response.

### FAQ

#### Do I need to log in or provide cookies to scrape Instagram post likes?

You don’t have to, but it’s recommended. Without sessionId, Instagram may return a login page and 0 users. Supplying sessionId enables authenticated requests for more reliable results.

#### What exactly does this Instagram likers scraper collect?

It collects user profile fields and engagement context: full\_name, id, username, is\_private, is\_verified, profile\_pic\_url, liked\_post/post\_url, total\_likes, and extra API fields like latest\_reel\_media, latest\_reel\_media\_utc, profile\_pic\_id, and is\_new.

#### How many users can I extract per run?

You control this via maxCount. The allowed range is 1–10,000 unique users across all input posts. The actor stops when it reaches your limit.

#### Can I process multiple post URLs at once?

Yes. Add multiple Instagram post URLs to startUrls to run this IG likes scraper tool in bulk across many posts.

#### How does the proxy handling work?

The actor starts with no proxy. If blocked, it falls back to a datacenter proxy, and then to residential proxies with retries. You’ll see clear \[PROXY] logs indicating the current mode.

#### Does it scrape private posts or access private data?

No. It retrieves data from public posts. The actor respects access constraints; private or login-gated content won’t be available unless you provide a valid sessionId.

#### What export formats are supported?

You can export Instagram likes data to JSON or CSV from the Apify run’s OUTPUT tab. Each user is saved live, so you can download partial results at any time.

#### Is there a trial or subscription?

This actor is available with a flat monthly subscription. The listing includes trial minutes to evaluate the tool before committing. Check the Apify Store page for the latest pricing details.

### Closing CTA / Final thoughts

Instagram Likes Scraper is built to reliably scrape Instagram post likes and commenters into clean, structured engagement datasets. With smart proxy fallback, live dataset saving, and deduplicated outputs, it’s a dependable Instagram likes scraping tool for marketers, developers, analysts, and researchers.

Set your startUrls, choose a maxCount, and optionally add sessionId for authenticated runs. Export Instagram likes list results as JSON or CSV for analytics, enrichment, and reporting. Start extracting smarter Instagram engagement data today with a robust Instagram likes API alternative.

# Actor input Schema

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

🔗 Paste one or more Instagram post URLs (e.g. https://www.instagram.com/p/XXXXX/). We'll collect likers + commenters from each.

## `maxCount` (type: `integer`):

📈 Cap on unique users (likers + commenters) across all posts. 1–10,000. Default: 1000.

## `sessionId` (type: `string`):

Paste your Instagram sessionid cookie value for authenticated requests. Get it from browser: DevTools → Application → Cookies → instagram.com → sessionid. Without it, requests may return 0 users (login page).

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

🛡️ Leave off for direct requests. If Instagram blocks you, we auto fallback: datacenter → residential (with retries).

## Actor input object example

```json
{
  "startUrls": [
    "https://www.instagram.com/p/DLm63qQpxvw/"
  ],
  "maxCount": 100,
  "sessionId": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.instagram.com/p/DLm63qQpxvw/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilotapi/instagram-likes-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 = {
    "startUrls": ["https://www.instagram.com/p/DLm63qQpxvw/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/instagram-likes-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 '{
  "startUrls": [
    "https://www.instagram.com/p/DLm63qQpxvw/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapepilotapi/instagram-likes-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Likes Scraper",
        "description": "👍 Instagram Likes Scraper (instagram-likes-scraper) collects usernames, profile IDs, and timestamps from public post likes — fast and accurate. 📊 Export CSV/JSON for engagement analysis, influencer vetting, competitor research, and growth. ⚡ Perfect for marketers & analysts.",
        "version": "0.1",
        "x-build-id": "42oj8KDGZc5Vqq0Sq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~instagram-likes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-instagram-likes-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/scrapepilotapi~instagram-likes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-instagram-likes-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/scrapepilotapi~instagram-likes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-instagram-likes-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "📎 Post URLs",
                        "type": "array",
                        "description": "🔗 Paste one or more Instagram post URLs (e.g. https://www.instagram.com/p/XXXXX/). We'll collect likers + commenters from each.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCount": {
                        "title": "🎯 Max users to collect",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "📈 Cap on unique users (likers + commenters) across all posts. 1–10,000. Default: 1000.",
                        "default": 100
                    },
                    "sessionId": {
                        "title": "🔐 Instagram session ID (optional)",
                        "type": "string",
                        "description": "Paste your Instagram sessionid cookie value for authenticated requests. Get it from browser: DevTools → Application → Cookies → instagram.com → sessionid. Without it, requests may return 0 users (login page).",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy (optional)",
                        "type": "object",
                        "description": "🛡️ Leave off for direct requests. If Instagram blocks you, we auto fallback: datacenter → residential (with retries)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
