# Instagram Mention Scraper (`scraperoka/instagram-mention-scraper`) Actor

🔍 Instagram Mention Scraper pulls valuable mention data from posts, captions & hashtags—fast, accurate, and export-ready. 📈 Perfect for brand monitoring, influencer research, competitive insights & campaign tracking.

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Mention Scraper 🚀

Manually reviewing Instagram posts to spot mentions and tags wastes hours you don’t have. **Instagram Mention Scraper** pulls structured post metadata from any public Instagram profile and extracts user mentions, hashtags, and tagged users—ideal for marketers, recruiters, and growth teams building faster mention analytics. Instagram mention scraper output helps teams scale discovery and monitoring with thousands of records in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "inputUrl": "https://www.instagram.com/natgeo",
  "id": "12345678901234567",
  "type": "Image",
  "shortCode": "Ck9aZpXqLmT",
  "caption": "Amazing moments by @nature and #wildlife. Tag your favorite places! @exploreearth",
  "hashtags": ["wildlife"],
  "mentions": ["nature", "exploreearth"],
  "url": "https://www.instagram.com/p/Ck9aZpXqLmT/",
  "commentsCount": 124,
  "latestComments": [
    {
      "id": "9988776655",
      "text": "Incredible shots!",
      "ownerUsername": "photoeditor",
      "ownerId": "7766554433",
      "timestamp": "2025-05-12T14:30:10.000Z"
    }
  ],
  "dimensionsHeight": 1080,
  "dimensionsWidth": 1080,
  "displayUrl": "https://example.com/images/post.jpg",
  "images": ["https://example.com/images/post.jpg"],
  "likesCount": 5321,
  "videoPlayCount": 0,
  "timestamp": "2025-05-12T14:22:00.000Z",
  "childPosts": [],
  "locationName": "Serengeti National Park",
  "ownerFullName": "National Geographic",
  "ownerUsername": "natgeo",
  "ownerId": "1234567890",
  "productType": "feed",
  "taggedUsers": [
    {
      "full_name": "Explore Earth",
      "id": "2223334445",
      "username": "exploreearth"
    }
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `inputUrl` | string | The profile URL context for the scrape |
| `id` | string | Unique identifier for the post record in this output |
| `type` | string | Post media type (for example, Image, Video, Sidecar) |
| `shortCode` | string | Short code used to build the post URL |
| `caption` | string | Raw caption text for mention and hashtag analysis |
| `hashtags` | array | Hashtags extracted from the caption text (e.g., for hashtag mention scraper workflows) |
| `mentions` | array | User mentions extracted from the caption text (useful for instagram dm mention scraper style analysis—even when you’re studying mentions only) |
| `url` | string | Direct post URL for verification and linking back to sources |
| `commentsCount` | number | How many comments the post has |
| `latestComments` | array | A preview list of the latest comment objects returned with the post |
| `dimensionsHeight` | number | Media height (useful if you’re analyzing assets) |
| `dimensionsWidth` | number | Media width (useful if you’re analyzing assets) |
| `likesCount` | number | Like count for engagement analysis |
| `timestamp` | string | When the post was taken (formatted timestamp string) |
| `taggedUsers` | array | Users tagged in the post (helps your mention monitoring and influencer lists) |
| `status` / `error_message` | not present in code | Output records are pushed per post without a dedicated `status` or `error_message` field in the provided implementation |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Instagram Mention Scraper?

There are a lot of ways to pull data from Instagram — here’s what sets Instagram Mention Scraper (and related instagram mentions extraction tool workflows) apart.

#### Post-level mention and hashtag extraction

Instagram mention scraper structures each post into a detailed record, including `mentions` and `hashtags` derived directly from the caption text. This makes it easier to build mention analytics without manual cleanup.

#### Tagged user capture for deeper context

Beyond plain text mentions, the output also includes `taggedUsers` from tagged users in the post. That’s useful when you’re doing an instagram user mention scraper style workflow focused on who was actually tagged.

#### Complete metadata with useful engagement fields

Each record includes `likesCount`, `commentsCount`, and `latestComments` (with `timestamp`, `ownerUsername`, and `text`). This lets teams correlate mentions and tags with engagement performance for instagram mentions tracker tool reporting.

#### Built-in resilience for smoother runs

The actor is designed for reliability across multiple pages of posts, with pacing between requests and error handling around pagination. It’s a practical fit for instagram mention collection software and ongoing mention monitoring.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "username": "natgeo",
  "maxPosts": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `username` | ✅ | The Instagram username you want to scrape (for example, `natgeo`) |
| `maxPosts` | ⬜ | Total number of latest posts to scrape (default is `50`, minimum is `1`) |

***

### Core Capabilities

#### Structured post extraction from any public profile

Instagram Mention Scraper scrapes posts from the provided public profile and returns a structured post object for each item. This gives you consistent fields for mentions, hashtags, and tagged users for downstream analysis.

#### Caption intelligence for mentions and hashtags

The actor extracts `hashtags` and `mentions` from the post `caption` text. That’s ideal for instagram hashtag mention scraper and instagram comment scraper mentions style analyses focused on who shows up in captions.

#### Detailed output you can plug into reporting

Results include engagement signals (`likesCount`, `commentsCount`), media dimensions (`dimensionsHeight`, `dimensionsWidth`), and comment previews (`latestComments`). You can use instagram mentions export workflows to move this data directly into your reporting stack.

#### Resilient pagination and pacing

The actor fetches posts in pages until it reaches `maxPosts` or runs out of available items. It also includes delays between requests to improve stability during longer runs.

#### Works cleanly at automation scale

Because output is pushed record-by-record, you can run Instagram Mention Scraper repeatedly and integrate it with your pipeline via the Apify dataset. This supports instagram mention monitoring and analytics tool use cases without manual copy-paste.

***

### Who Gets the Most Out of This

Here’s how different teams put Instagram Mention Scraper to work:

**Influencer marketers** — Use the mention analytics from `mentions`, `hashtags`, and `taggedUsers` to quickly shortlist creators and understand how a brand is referenced across posts. The result is a cleaner, faster workflow for instagram tag mention scraper and mention monitoring.

**Growth teams and community managers** — Pull a profile’s latest posts and analyze what users consistently tag or mention. This helps turn instagram mentions tracker tool tracking into structured datasets you can review weekly.

**Recruiters and talent sourcing researchers** — Extract mentions and tagged users from relevant profiles to build relationship maps and track community involvement over time. It’s a practical instagram mention finder approach when you’re creating candidate-adjacent signals.

**Data analysts and analysts** — The consistent JSON record structure makes it easier to load into a spreadsheet or warehouse, then run text-based breakdowns on `caption` derived fields. You can combine mentions and hashtag activity with `likesCount` and `commentsCount` for stronger insights.

**Automation specialists / developers** — Integrate the actor into scheduled runs, fetch results via the Apify API, and push them to your own systems for ongoing instagram mentions export and reporting.

**Social listening operators** — Use the extracted mention and hashtag fields to support ongoing monitoring and build trend reports from posted content. It’s a reliable instagram mentions extraction tool approach for repeated collection.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Instagram Mention Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find Instagram Mention Scraper.
2. **Enter your inputs** — set `username` (required) and optionally `maxPosts` to control how many latest posts you want.
3. **Configure proxy settings** — if your account setup supports proxies, enable them for improved reliability on longer runs.
4. **Hit Run and watch the live log** — monitor progress as pages of posts are fetched and converted into structured records.
5. **View results in the dataset tab** — each post is pushed as a JSON record as it’s scraped.
6. **Export as JSON, CSV, or Excel** — download from the dataset tab for analysis, sharing, or importing.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Instagram Mention Scraper plugs directly into your existing workflow.

You can export results in common formats like JSON, CSV, or Excel from the Apify dataset tab. For automation, you can connect the run to your tools using Apify’s API and supported integrations such as Zapier or Make to move datasets into your CRM, dashboards, or internal systems.

If you need continuous monitoring, schedule runs so mention monitoring stays current without manual effort. For API-driven workflows, see Apify’s API documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

Instagram Mention Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll run on Apify compute with pay-as-you-go billing (based on Actor compute units), so you can scale from small tests to bigger collection jobs.

Apify also provides subscription plans for heavier usage, and pricing depends on your selected plan and run characteristics. For the most accurate, up-to-date costs, check the Apify pricing page.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limits | Built-in pacing and request management for steadier scraping |
| Access instability | Error handling and fallback behavior to keep runs moving |
| Multi-page extraction | Pagination continues until `maxPosts` is reached or no more items are available |
| Output completeness | Each scraped post is pushed as a structured record, ready for export |
| Run stability | Includes retries/fallback behavior for resilience during collection |

**Limitations:** The actor works with publicly accessible Instagram profile content. Private or login-gated content is not accessible through this actor, and the availability of mentions/hashtags depends on what’s in each post caption.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial for Instagram Mention Scraper?

Yes. Apify provides a free tier so you can run Instagram Mention Scraper with limited usage before scaling up. Check the current offer in your Apify account for exact credit details.

#### Do I need to log in to Instagram to use this?

No. This actor targets publicly available Instagram profile data and does not require an Instagram login for the scrape described here.

#### How accurate is the data extracted by Instagram Mention Scraper?

The actor extracts metadata and derives `hashtags` and `mentions` directly from each post `caption` field as returned in the feed data. Accuracy therefore depends on what the account publishes in captions and tagged content.

#### How many results can I get per run?

You control the cap with `maxPosts`, which defaults to `50` and has a minimum of `1`. The actor stops once it reaches that limit or there are no more posts available.

#### How fresh is the data?

It’s as fresh as the “latest posts” available at the time you run the actor. The output includes a `timestamp` field formatted from the post’s captured time.

#### Is this legal? Does it comply with GDPR / CCPA?

Use of publicly available data is subject to your own compliance responsibilities. Make sure your use case follows GDPR, CCPA, Instagram’s Terms of Service, and any applicable local regulations.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab and import into Google Sheets or Excel. If you need automation, you can also use Zapier or Make to route exported data to other systems.

#### Can I run this on a schedule automatically?

Yes. You can schedule Apify actors to run automatically on a cron schedule, which is useful for instagram mentions tracker tool and ongoing monitoring.

#### Can I access this via API?

Yes. You can trigger runs and retrieve results programmatically via the Apify API. For details, use https://apify.com/docs/api.

#### What happens if the actor hits an error?

When requests fail, the actor logs the error and stops the current pagination flow. The records collected and pushed before the failure remain in your dataset for partial results.

***

### Need Help or Have a Request?

Got a question about Instagram Mention Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with run inputs and troubleshooting, and we actively maintain the actor based on community feedback. Concrete feature ideas like “keyword-based mention monitoring” or “webhook notifications on completion” are especially welcome.

***

### Disclaimer & Responsible Use

*Instagram Mention Scraper is the fastest, most reliable way to extract structured Instagram mention metadata — start your free run today.*

This actor collects **publicly available data** from Instagram. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, platform ToS, and any applicable regulations. For data-removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `username` (type: `string`):

Enter the Instagram username you want to scrape (e.g., natgeo).

## `maxPosts` (type: `integer`):

Total number of latest posts to scrape.

## Actor input object example

```json
{
  "username": "google",
  "maxPosts": 50
}
```

# 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 = {
    "username": "google"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/instagram-mention-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 = { "username": "google" }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/instagram-mention-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 '{
  "username": "google"
}' |
apify call scraperoka/instagram-mention-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Mention Scraper",
        "description": "🔍 Instagram Mention Scraper pulls valuable mention data from posts, captions & hashtags—fast, accurate, and export-ready. 📈 Perfect for brand monitoring, influencer research, competitive insights & campaign tracking.",
        "version": "1.0",
        "x-build-id": "ab1FjCBi5gjg1oyiI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~instagram-mention-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-instagram-mention-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/scraperoka~instagram-mention-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-instagram-mention-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/scraperoka~instagram-mention-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-instagram-mention-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": [
                    "username"
                ],
                "properties": {
                    "username": {
                        "title": "Instagram Username",
                        "type": "string",
                        "description": "Enter the Instagram username you want to scrape (e.g., natgeo)."
                    },
                    "maxPosts": {
                        "title": "Maximum Posts",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Total number of latest posts to scrape.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
