# Instagram Story Downloader (`scrapecraze/instagram-story-downloader`) Actor

Instagram Story Downloader helps you save publicly available Instagram Stories quickly and efficiently. Download story photos and videos for content research, social media monitoring, trend analysis, archiving, and offline viewing with a fast and reliable workflow.

- **URL**: https://apify.com/scrapecraze/instagram-story-downloader.md
- **Developed by:** [ScrapeCraze](https://apify.com/scrapecraze) (community)
- **Categories:** Social media, Automation, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.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 Story Downloader ⚡
Scraping Instagram stories one profile at a time is slow and painful—especially when you need videos and photos in a repeatable workflow. **Instagram Story Downloader** quickly scrapes story media for the usernames or profile URLs you provide and returns structured results you can analyze or export. It’s ideal for an instagram story downloader workflow like download instagram story and instagram story saver, and it fits creators, marketers, and researchers who want view and download instagram stories without manual copy-paste. In a single run, you can process multiple profiles and get stories_count plus a ready-to-use stories list with video and image URLs.

---

### See the Data: Sample Output
Here's a real record from a single run:

```json
{
  "username": "neymarjr",
  "stories_count": 3,
  "stories": [
    {
      "mediatype": "video",
      "story": "https://scontent.cdninstagram.com/.../video.mp4",
      "thumbnail": "https://scontent.cdninstagram.com/.../thumbnail.jpg"
    },
    {
      "mediatype": "image",
      "story": "https://scontent.cdninstagram.com/.../image.jpg"
    },
    {
      "mediatype": "image",
      "story": "https://scontent.cdninstagram.com/.../image.jpeg"
    }
  ]
}
````

Output fields written to the dataset:

| Field | Type | What It Tells You |
|---|---|---|
| `username` | string | The Instagram username the actor processed for this result record. |
| `stories_count` | number | How many stories passed validation for this profile (videos + images). |
| `stories` | array | The list of story media items returned for this username. |
| `stories[].mediatype` | string | Whether the story is a `video` or an `image` (useful for filtering). |
| `stories[].story` | string | The media URL for the story item (video MP4 URL or image URL). |
| `stories[].thumbnail` | string | Thumbnail URL for `video` stories (present when the story has video media). |
| `error` | string | Populated when processing fails for a given input (e.g., username extraction or request errors). |
| `input` | string | The original input value that was attempted (username, or a URL string). |

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

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

```json
{
  "startUrls": [
    "neymarjr",
    "https://www.instagram.com/cristiano/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | Provide one or more Instagram profile URLs (like `https://www.instagram.com/username`) or plain usernames (like `username`) to scrape stories from. |
| `proxyConfiguration` | ⬜ | Configure proxy settings for the run to improve scraping reliability. |
| ↳ `proxy support` | ⬜ | When set to `true`, routes the scraper through Apify Proxy. |

***

### What It Does

Instagram Story Downloader processes each input profile, extracts the story media it can validate, and writes results to your Apify dataset as they complete.

#### Scrapes story media for requested profiles

You send `startUrls`, and the actor returns structured story entries per processed `username`. Results include both videos and photos, suitable for an instagram story video downloader or instagram story photo downloader workflow.

#### Uses story URL validation to keep results clean

Not every discovered media link is accepted. The actor validates story URLs and only keeps stories that meet its validation rules, aiming for reliable output for instagram story saver use cases.

#### Produces a consistent dataset schema for easy filtering

Each record includes `username`, `stories_count`, and a `stories` array where each item includes `mediatype` plus the story URL. Video items also include `thumbnail`, making it straightforward to preview and categorize downloads like download instagram story and view and download instagram stories.

#### Handles failures per input without stopping the whole run

If an individual profile fails (for example, it can’t extract a username from your input), the actor still pushes an error record to the dataset. That means your batch keeps going and you can review `error` values for specific inputs.

#### Built-in proxy support for more reliable scraping

If you enable `proxyConfiguration`, the actor uses proxy settings to improve consistency across profiles. If the selected proxy is rejected, it falls back as described in the input configuration.

Overall, Instagram Story Downloader turns a list of instagram story download online requests into a clean, exportable dataset you can use immediately.

***

### Why Instagram Story Downloader?

There are plenty of ways to pull data from Instagram stories — here’s why Instagram Story Downloader stands out.

#### Story-first output that’s ready for downstream work

Instead of dumping unstructured pages, it returns a dataset record with `stories_count` and a `stories` array containing `mediatype`, `story`, and (for videos) `thumbnail`. That makes it easy to build an instagram story downloader pipeline that outputs consistent media links for analysis or sharing.

#### Reliable batch processing with retries and fallbacks

The actor includes retry logic for requests and can fall back when proxy settings are rejected. For teams running larger batches of instagram highlight downloader-style workflows, this reduces the “stop and restart” pain.

#### Simple input: usernames or profile URLs

You can pass either usernames or full profile URLs in `startUrls`, which keeps setup quick for marketers, analysts, and researchers. This is a practical fit for download private instagram story research scenarios as long as the stories and media are publicly accessible through the actor’s supported flow.

***

### Real-World Use Cases

Here's how different teams put Instagram Story Downloader to work:

**Influencer marketing teams**\
A campaign manager has a shortlist of creators and needs the story media URLs for creative review and reuse checks. They run the actor with the creators’ usernames, then export the dataset and filter by `mediatype` to separate video moments from images. The result is faster shortlisting and less time spent manually gathering story links.

**Sales and growth researchers**\
A researcher is building a dataset of creator activity and engagement patterns. They feed a list of instagram story saver targets into the actor and use `stories_count` to compare output volume across profiles. With structured `stories` entries, they can analyze what media types show up most often.

**Content operations for agencies**\
An agency wants to quickly review story formats across a client’s audience. They download instagram story content links for multiple profiles in one run, then preview and organize video thumbnails and image URLs using the dataset schema. This helps teams move from discovery to action without constant copy-paste.

**Automation specialists and data engineers**\
A developer wants to plug story media data into an existing data pipeline. They run Instagram Story Downloader, pull results from the dataset, and load `username` + `stories` into their warehouse for reporting or dashboards. The consistent fields make integration straightforward for an instagram story video downloader or instagram story photo downloader workflow.

**Community and brand monitoring**\
A brand coordinator tracks how competitors show content over time. They run the actor for the relevant profile URLs on a schedule, then compare `stories_count` and media presence across runs. This supports ongoing monitoring with minimal manual effort.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify**\
   Go to the actor page on Apify via `https://console.apify.com`.

2. **Enter your inputs**\
   Add your usernames or profile URLs in `startUrls` (you can mix plain usernames and `https://www.instagram.com/username/` URLs).

3. **(Optional) Configure proxy settings**\
   If you want to improve scraping reliability, set `proxyConfiguration` and enable `proxy support`.

4. **Start the run and watch progress**\
   Launch the actor and check the live logs to see each input being processed.

5. **Open the Dataset tab**\
   Results are pushed per input as the run proceeds, so you can review records immediately.

6. **Export your results**\
   Download the dataset from the Apify dashboard in your preferred format (JSON, CSV, or Excel).

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Instagram Story Downloader fits directly into your existing workflow.

You can export results from the Apify dataset tab as JSON, CSV, or Excel, which is ideal for offline analysis, spreadsheets, and quick sharing with stakeholders. For automation, you can connect the actor run to downstream tools using Apify’s API and standard integration approaches such as webhooks, Zapier, or Make.

If you want to run it on a schedule, you can configure recurring actor runs so your instagram story downloader dataset stays updated automatically.

***

### Pricing

Instagram Story Downloader runs on Apify, which includes a **free tier** — no credit card needed to start. Free tier usage provides `$5` platform credits on sign-up, enough for several real test runs. For ongoing work, runs are billed per Actor compute unit (CU) rather than per-row or per-export, and Apify plans support heavier workloads. Start free at `https://apify.com` — scale up when you need.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate limiting and server rejections | Retries with fallback behavior and short waits between attempts. |
| Proxy rejection scenarios | Uses the configured proxy and can fall back when a proxy is rejected (as described in the input config). |
| Unparseable inputs | Pushes an error record to the dataset when username extraction fails. |
| Incomplete story availability | Validates stories and returns an empty `stories` list when validation isn’t met. |
| Batch processing | Processes each item and pushes results per input so one failure doesn’t stop the run. |

Limitations: the actor processes publicly accessible data and does not support private or login-gated content. If a profile doesn’t yield valid story media links that pass validation, you may receive `stories_count: 0`.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes, Apify offers a free tier with sign-up credits, which is enough for several test runs. For heavier workloads, you’ll switch to the appropriate paid plan on Apify.

#### Do I need to log in or create an account on Instagram?

No. The actor works using the inputs you provide (`startUrls`) and scrapes publicly accessible story media. No Instagram login or account is required for the actor run itself.

#### How accurate is the extracted data?

Accuracy depends on what story media links are available and how they pass the actor’s validation checks. The output is only kept when story URLs pass validation, which helps reduce noise for your download instagram story workflow.

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

Your results depend on how many entries you provide in `startUrls` and how many stories are available per profile. Each output record includes `stories_count` and a `stories` array for that specific username.

#### How fresh is the data?

The data freshness depends on when you run the actor. If you schedule runs, you can keep your instagram story downloader dataset updated over time.

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

The actor is designed to work with **publicly available data**. It’s your responsibility to comply with GDPR, CCPA, Instagram’s Terms of Service, and any applicable local regulations for how you store and use the results.

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

Yes. You can export your dataset from the Apify dashboard as JSON, CSV, or Excel, then import it into Google Sheets or another spreadsheet tool. For direct workflow automation, you can also use integrations like Zapier or Make.

#### Can I schedule this to run automatically?

Yes. You can schedule Apify actor runs on a cron-like schedule using Apify’s scheduling features. This is useful when you want recurring instagram story video downloader or instagram highlight downloader monitoring.

#### Can I access results via the API?

Yes. You can access results programmatically using Apify’s API patterns and retrieve dataset items produced by the run.

#### What happens when the actor encounters an error?

The actor pushes an error record to the dataset for the specific input that failed, including `error`, `input`, `stories_count`, and `stories: []` where applicable. The run continues so you don’t lose the rest of the batch.

***

### Get Help & Use Responsibly

Got a question about Instagram Story Downloader or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup, dataset interpretation, and improvements like adding more output fields or better run-level reporting.

***

**publicly available data** only. The actor does not access private accounts, login-gated pages, or password-protected content. You’re responsible for GDPR, CCPA, and platform terms compliance when using the extracted results. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

Enter one or more Instagram profile URLs (e.g., https://www.instagram.com/username) or just usernames (e.g., username).

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

Select proxies to be used by the scraper. If the selected proxy is rejected by Instagram, a residential proxy will be used as a fallback.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.instagram.com/neymarjr/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        {
            "url": "https://www.instagram.com/neymarjr/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapecraze/instagram-story-downloader").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": [{ "url": "https://www.instagram.com/neymarjr/" }],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapecraze/instagram-story-downloader").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": [
    {
      "url": "https://www.instagram.com/neymarjr/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapecraze/instagram-story-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Story Downloader",
        "description": "Instagram Story Downloader helps you save publicly available Instagram Stories quickly and efficiently. Download story photos and videos for content research, social media monitoring, trend analysis, archiving, and offline viewing with a fast and reliable workflow.",
        "version": "0.1",
        "x-build-id": "YOmEKHhWLTOsadfJs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapecraze~instagram-story-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapecraze-instagram-story-downloader",
                "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/scrapecraze~instagram-story-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scrapecraze-instagram-story-downloader",
                "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/scrapecraze~instagram-story-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scrapecraze-instagram-story-downloader",
                "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": "Instagram Username or Profile URL",
                        "type": "array",
                        "description": "Enter one or more Instagram profile URLs (e.g., https://www.instagram.com/username) or just usernames (e.g., username).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by the scraper. If the selected proxy is rejected by Instagram, a residential proxy will be used as a fallback."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
