# Intercom App Store Scraper (`automation-lab/intercom-app-store-scraper`) Actor

Extract Intercom App Store apps, vendors, categories, install links, pricing signals, docs, and integration metadata for marketplace research.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Intercom App Store Scraper

Extract Intercom App Store integrations, categories, vendors, pricing signals, install links, setup text, and marketplace metadata from public Intercom App Store data.

Intercom App Store Scraper turns the public marketplace at `intercom.com/app-store` into a structured dataset for partnership research, SaaS ecosystem mapping, integration intelligence, and lead generation.

### What does Intercom App Store Scraper do?

This actor collects public Intercom App Store app listings through Intercom's public app-store API.

It can export the whole marketplace, focus on specific category slugs, run marketplace search queries, or fetch known app package IDs.

Each app row includes vendor/developer signals, category labels, capability tags, pricing and install signals, documentation/support links, media URLs, setup snippets, and source URLs.

### Who is it for?

- 🤝 SaaS partnership teams mapping companies that build in the Intercom ecosystem.
- 📈 Marketplace analysts tracking category coverage, app positioning, and pricing signals.
- 🧲 Lead-generation teams finding vendors with Intercom integrations.
- 🧪 Product teams benchmarking onboarding, install flows, and integration messaging.
- 🗂️ Data teams building repeatable app-store enrichment pipelines.

### Why use it?

The Intercom App Store is useful but optimized for browsing, not analysis.

This actor provides repeatable exports with stable field names, deduplication, API-friendly output, and a low-cost HTTP implementation.

Use it when you need Intercom ecosystem data in CSV, JSON, Google Sheets, a CRM, or a data warehouse.

### How much does it cost to scrape Intercom App Store apps?

The actor uses pay-per-event pricing.

- Start event: a small one-time run fee.
- Item event: one charge per saved app or category record.
- You control spend with `maxItems` and filters.

Final live prices are shown on the Apify Store pricing panel and are reflected in run charging events.

### Data fields

| Field | Description |
| --- | --- |
| `recordType` | `app` or `category` |
| `recordId` | Intercom app package or category ID |
| `name` | App or category name |
| `appStoreUrl` | Public Intercom App Store URL |
| `description` | Short marketplace description |
| `longDescription` | Longer app positioning/setup text when available |
| `builtBy` | Intercom or third-party developer name |
| `developerHomepageUrl` | Developer or learn-more page |
| `installUrl` | Install/connect URL exposed by Intercom |
| `installType` | OAuth/manual/internal install signal |
| `pricingModel` | Public pricing/trial/free signal |
| `pricingPageUrl` | Vendor pricing URL when provided |
| `supportEmail` | Support contact when provided |
| `documentationUrl` | Help docs or integration docs |
| `categories` | Intercom category names |
| `categorySlugs` | Intercom category slugs |
| `capabilities` | Intercom capability labels |
| `whatItDoes` | Extracted guide text around what the app does |
| `setupRequirements` | Extracted requirements text |
| `setupSteps` | Setup/connect headings |
| `featureBullets` | Bullet points from guide blocks |
| `iconUrl`, `imageUrls`, `videoUrl` | Media assets |
| `scrapedAt` | ISO timestamp for the run |

### Input options

#### `maxItems`

Maximum number of records to save. Use a small value for smoke tests and 100+ for marketplace analysis.

#### `includeAllApps`

Fetch the full public Intercom app catalog before applying `maxItems`. This is enabled by default.

#### `searchQueries`

Run Intercom App Store searches such as `slack`, `analytics`, `hubspot`, `ai`, or `zendesk`.

#### `categories`

Limit extraction to Intercom category slugs such as `analytics`, `automation`, `crm`, `data-and-enrichment`, `for-support-teams`, or `for-sales-teams`.

#### `appPackageIds`

Fetch specific known app slugs, for example `google-analytics`, `salesforce-by-intercom`, or `jira-for-intercom-4g7a`.

#### `includeCategoryRecords`

Also output Intercom category taxonomy records. App rows remain the main dataset.

### Example input: full marketplace sample

```json
{
  "maxItems": 100,
  "includeAllApps": true,
  "includeCategoryRecords": false
}
````

### Example input: search-based lead list

```json
{
  "maxItems": 50,
  "includeAllApps": false,
  "searchQueries": ["slack", "analytics", "crm"]
}
```

### Example input: category monitoring

```json
{
  "maxItems": 150,
  "includeAllApps": false,
  "categories": ["analytics", "automation", "data-and-enrichment"],
  "includeCategoryRecords": true
}
```

### Example output

```json
{
  "recordType": "app",
  "recordId": "salesforce-by-intercom",
  "name": "Salesforce",
  "appStoreUrl": "https://www.intercom.com/app-store/salesforce-by-intercom",
  "description": "Sync data and streamline workflows for sales, marketing and support",
  "builtBy": "Intercom",
  "pricingModel": "free_trial_available",
  "installType": "requires_oauth",
  "categories": ["CRM", "For sales teams"],
  "documentationUrl": "https://docs.intercom.com/integrations/integrate-with-salesforce",
  "scrapedAt": "2026-07-08T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Set `maxItems` to the number of records you need.
3. Choose full catalog mode or provide search/category filters.
4. Start the run.
5. Download the dataset as JSON, CSV, Excel, or via API.

### Tips for better results

- Use `includeAllApps: true` for broad ecosystem mapping.
- Use category filters when tracking a specific GTM segment.
- Use search queries for competitor or partner discovery.
- Keep scheduled runs under a fixed `maxItems` to control cost.
- Use `scrapedAt` to compare snapshots over time.

### Integrations

Common workflows include:

- Export Intercom ecosystem leads to HubSpot or Salesforce.
- Join app names and developer URLs with enrichment tools.
- Monitor new apps by comparing scheduled datasets.
- Feed category coverage data into BI dashboards.
- Send pricing/support/documentation URLs to partnership researchers.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/intercom-app-store-scraper').call({
  maxItems: 100,
  includeAllApps: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/intercom-app-store-scraper').call(run_input={
    'maxItems': 100,
    'includeAllApps': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~intercom-app-store-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"includeAllApps":true}'
```

### MCP: use from Claude Desktop or Claude Code

Connect Apify MCP with this actor enabled.

Claude Code CLI setup:

```bash
claude mcp add apify-intercom-app-store "https://mcp.apify.com/?tools=automation-lab/intercom-app-store-scraper"
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/intercom-app-store-scraper"
    }
  }
}
```

Example prompts:

- "Run the Intercom App Store Scraper for 100 apps and summarize the most common pricing models."
- "Find Intercom App Store apps in analytics and CRM categories with public pricing URLs."
- "Compare today's Intercom app export with last week's dataset and list new vendors."

### Scheduling and monitoring

Schedule weekly or monthly runs to detect new app listings, category changes, or updated pricing/documentation links.

For monitoring, keep `includeAllApps` enabled and set `maxItems` high enough to cover the catalog.

### Data freshness

The actor reads Intercom's public app-store API at run time.

Results reflect public data visible during the run, including Intercom-side ordering, public fields, and currently exposed integration metadata.

### Limitations

- The actor extracts public marketplace metadata only.
- It does not log into Intercom workspaces.
- It does not install apps or verify OAuth flows.
- Review/rating fields are included only if Intercom exposes them publicly in the source data.
- Vendor websites linked from the marketplace are not crawled.

### Troubleshooting

If a run returns fewer records than expected, check whether `maxItems`, search queries, category slugs, or app package IDs narrowed the output.

If a category query returns zero rows, verify the slug from an Intercom category URL or run with `includeCategoryRecords` to inspect available slugs.

If you need every app, use `includeAllApps: true` and a `maxItems` value above the current catalog size.

### Legality: is it legal to scrape the Intercom App Store?

This actor collects public marketplace metadata. You are responsible for using the data lawfully, respecting applicable terms, and complying with privacy and database laws in your jurisdiction.

Do not use the output for spam, deceptive outreach, or any workflow that violates Intercom's or vendors' rights.

### Related scrapers

Other Automation Lab marketplace and ecosystem actors that may help adjacent workflows:

- https://apify.com/automation-lab/monday-app-marketplace-scraper
- https://apify.com/automation-lab/aws-marketplace-scraper
- https://apify.com/automation-lab/zoho-marketplace-scraper
- https://apify.com/automation-lab/atlassian-marketplace-scraper

### FAQ

#### Can it scrape all Intercom App Store apps?

Yes. Use `includeAllApps: true` and set `maxItems` high enough to cover the catalog.

#### Can it scrape app detail pages?

The actor uses the public API that powers the detail pages, so it captures the structured detail fields without browser rendering.

#### Does it require proxies?

No proxy is required for the public API in normal use.

#### Can I get only Slack-related apps?

Yes. Set `includeAllApps` to `false` and `searchQueries` to `["slack"]`.

#### Can I monitor categories over time?

Yes. Schedule recurring runs with category filters and compare datasets by `recordId` and `scrapedAt`.

### Support

If you need an additional field that is publicly visible on Intercom App Store pages, open an Apify issue with the app URL and expected field.

# Actor input Schema

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

Maximum app/category records to save. Use 100+ for marketplace monitoring and pricing analysis.

## `includeAllApps` (type: `boolean`):

Fetch the public Intercom App Store catalog before applying the maximum record limit. If disabled, provide searches, categories, or app package IDs.

## `searchQueries` (type: `array`):

Optional Intercom App Store searches such as slack, analytics, hubspot, ai, or zendesk.

## `categories` (type: `array`):

Optional Intercom category slugs, for example analytics, automation, crm, data-and-enrichment, for-support-teams, or for-sales-teams.

## `appPackageIds` (type: `array`):

Optional direct Intercom app slugs/IDs, for example google-analytics, salesforce-by-intercom, or jira-for-intercom-4g7a.

## `includeCategoryRecords` (type: `boolean`):

Also output Intercom App Store category records alongside app listings.

## Actor input object example

```json
{
  "maxItems": 20,
  "includeAllApps": true,
  "searchQueries": [
    "analytics",
    "slack"
  ],
  "categories": [
    "analytics",
    "crm"
  ],
  "includeCategoryRecords": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 20,
    "includeAllApps": true,
    "searchQueries": [
        "analytics",
        "slack"
    ],
    "categories": [
        "analytics",
        "crm"
    ],
    "includeCategoryRecords": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/intercom-app-store-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 = {
    "maxItems": 20,
    "includeAllApps": True,
    "searchQueries": [
        "analytics",
        "slack",
    ],
    "categories": [
        "analytics",
        "crm",
    ],
    "includeCategoryRecords": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/intercom-app-store-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 '{
  "maxItems": 20,
  "includeAllApps": true,
  "searchQueries": [
    "analytics",
    "slack"
  ],
  "categories": [
    "analytics",
    "crm"
  ],
  "includeCategoryRecords": false
}' |
apify call automation-lab/intercom-app-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Intercom App Store Scraper",
        "description": "Extract Intercom App Store apps, vendors, categories, install links, pricing signals, docs, and integration metadata for marketplace research.",
        "version": "0.1",
        "x-build-id": "R3nOHWOpi1D0F4xSh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~intercom-app-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-intercom-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~intercom-app-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-intercom-app-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~intercom-app-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-intercom-app-store-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",
                "properties": {
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum app/category records to save. Use 100+ for marketplace monitoring and pricing analysis.",
                        "default": 20
                    },
                    "includeAllApps": {
                        "title": "Include all apps",
                        "type": "boolean",
                        "description": "Fetch the public Intercom App Store catalog before applying the maximum record limit. If disabled, provide searches, categories, or app package IDs.",
                        "default": true
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Optional Intercom App Store searches such as slack, analytics, hubspot, ai, or zendesk.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional Intercom category slugs, for example analytics, automation, crm, data-and-enrichment, for-support-teams, or for-sales-teams.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "appPackageIds": {
                        "title": "Specific app package IDs",
                        "type": "array",
                        "description": "Optional direct Intercom app slugs/IDs, for example google-analytics, salesforce-by-intercom, or jira-for-intercom-4g7a.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeCategoryRecords": {
                        "title": "Include category records",
                        "type": "boolean",
                        "description": "Also output Intercom App Store category records alongside app listings.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
