# Apify Store Scraper (`extractmaster01/apify-store-scraper`) Actor

Extract actor data from Apify Store using the official search API. Filter by category, pricing model, developer or keyword. Sort by popularity, newest or last updated. Get titles, stats, pricing, ratings and categories for any actor.

- **URL**: https://apify.com/extractmaster01/apify-store-scraper.md
- **Developed by:** [extractmaster01](https://apify.com/extractmaster01) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does Apify Store Scraper do?

**Apify Store Scraper** extracts structured data from the [Apify Store](https://apify.com/store) marketplace — the world's largest collection of web scraping and automation actors. Use it to **search, filter, and export data** from 24,000+ public actors in seconds, without writing a single line of code.

With this scraper, you can **filter actors by category, pricing model, rating, and user count**, then export everything as JSON or CSV. Each result includes the actor's title, description, pricing details, review score, and developer information — all in one clean, structured dataset.

---

### What can Apify Store Scraper extract?

The following data is extracted for each actor found in the Apify Store:

| Field | Description |
|---|---|
| `actorId` | Unique actor ID on the Apify platform |
| `url` | Direct link to the actor's Store page |
| `title` | Display title of the actor |
| `name` | URL slug (e.g. `google-maps-scraper`) |
| `username` | Developer's Apify username |
| `userFullName` | Developer's display name |
| `description` | Short description shown in the Store listing |
| `readmeSummary` | Auto-generated summary of the actor's README |
| `categories` | Categories the actor belongs to (e.g. `AI`, `SOCIAL_MEDIA`) |
| `managedBy` | `APIFY` (official) or `COMMUNITY` (independent developer) |
| `notice` | Status notice: `NONE`, `DEPRECATED`, `UNDER_MAINTENANCE` |
| `createdAt` | Publication date |
| `modifiedAt` | Date of last update |
| `totalUsers` | All-time total number of users |
| `bookmarkCount` | Number of times the actor was bookmarked |
| `actorReviewRating` | Average rating (1–5 scale) |
| `actorReviewCount` | Number of user reviews |
| `currentPricingInfo.pricingModel` | Pricing type: `FREE`, `PAY_PER_EVENT`, `FLAT_PRICE_PER_MONTH` |
| `currentPricingInfo.pricingPerEvent` | Price per event breakdown (if Pay Per Event model) |

---

### Why use Apify Store Scraper?

Whether you're a developer building tools on top of the Apify ecosystem or a researcher analyzing the marketplace, **Apify Store Scraper** gives you the data you need — instantly and at scale.

Here are the most common use cases:

- 🔍 **Market research** — analyze which actor categories and pricing models dominate the Store before building your own actor
- 🏆 **Competitor analysis** — benchmark actors in your niche by user count, rating, bookmarks, and pricing
- 👤 **Developer profiling** — collect all actors published by a specific username or organization
- 💡 **Tool discovery** — find the best-rated, most popular, or newest actors for a specific task
- 💰 **Pricing intelligence** — see what pricing models and price points are winning in each category
- 📊 **Ecosystem monitoring** — track new actors entering the Store or changes in popularity over time
- 🤖 **AI pipelines** — feed Store metadata into LLMs for automated actor recommendations or gap analysis

---

### How to use Apify Store Scraper

1. Click **Try for free** on this page
2. Set your **search query** (e.g. `"instagram"`, `"tiktok"`, `"google"`) or leave empty to get all actors
3. Choose filters: **category**, **pricing model**, **minimum rating**, or **maintainer** (Apify vs. Community)
4. Set the **maximum number of results** you need (up to 25,000 — the full Store catalog)
5. Click **Run** and wait a few seconds
6. **Download your data** from the Dataset tab as JSON, CSV, Excel, or XML

> 💡 **Tip:** Sort by `mostPopular` to get actors with the largest user base first. Sort by `newest` to monitor newly published actors.

---

### Input examples

#### Find all paid competitors in a category before launching your own actor

```json
{
    "maxItems": 200,
    "categories": ["LEAD_GENERATION"],
    "pricingModel": ["PAY_PER_EVENT", "FLAT_PRICE_PER_MONTH"],
    "minUsers": 100,
    "sortBy": "mostPopular"
}
````

#### Find the most popular TikTok scrapers

```json
{
    "query": "tiktok",
    "maxItems": 50,
    "sortBy": "mostPopular",
    "categories": ["SOCIAL_MEDIA"]
}
```

#### Find all free AI actors from Apify

```json
{
    "maxItems": 200,
    "categories": ["AI"],
    "pricingModel": ["FREE"],
    "managedBy": "APIFY"
}
```

#### Find all actors by a specific developer

```json
{
    "username": "apify",
    "maxItems": 1000,
    "sortBy": "mostPopular"
}
```

#### Find highly-rated lead generation actors

```json
{
    "maxItems": 100,
    "categories": ["LEAD_GENERATION"],
    "minRating": 4,
    "minUsers": 500,
    "sortBy": "mostPopular"
}
```

#### Export the entire Apify Store catalog

```json
{
    "maxItems": 25000,
    "sortBy": "mostPopular"
}
```

***

### Output example

Each item in the dataset represents one actor from the Apify Store:

```json
{
    "actorId": "nwua9Gu5YrADL7ZDj",
    "url": "https://apify.com/compass/crawler-google-places",
    "title": "Google Maps Scraper",
    "name": "crawler-google-places",
    "username": "compass",
    "userFullName": "Compass",
    "description": "Extract data from Google Maps — restaurants, hotels, shops, and more.",
    "readmeSummary": "A powerful scraper for Google Maps that extracts location data at scale.",
    "pictureUrl": "https://apify-image-uploads-prod.s3.amazonaws.com/...",
    "categories": ["LEAD_GENERATION", "TRAVEL"],
    "managedBy": "APIFY",
    "notice": "NONE",
    "isCritical": true,
    "createdAt": "2018-11-19T00:00:00.000Z",
    "modifiedAt": "2025-11-18T09:06:05.000Z",
    "totalUsers": 353992,
    "bookmarkCount": 3788,
    "actorReviewRating": 4.72,
    "actorReviewCount": 1139,
    "currentPricingInfo": {
        "pricingModel": "PAY_PER_EVENT",
        "pricingPerEvent": { "actor-run-succeeded": 5.0 },
        "minimalMaxTotalChargeUsd": null,
        "apifyMarginPercentage": 0.2,
        "startedAt": "2023-06-01T00:00:00.000Z"
    }
}
```

> **Note:** `currentPricingInfo` reflects the pricing of the actor being described (in this example, Google Maps Scraper charges $5.00 per 1,000 successful runs). This is data returned by the scraper — it is not related to the cost of running Apify Store Scraper itself.

***

### How much does it cost to run Apify Store Scraper?

**Apify Store Scraper** uses a **Pay Per Event** pricing model — you only pay for the actors successfully extracted.

| Use case | Results | Estimated cost |
|---|---|---|
| Quick market snapshot | 100 actors | ~$0.05 |
| Category analysis | 500 actors | ~$0.25 |
| Full developer catalog | 1,000 actors | ~$0.50 |
| Full Store export | 25,000 actors | ~$12.50 |

> 🎁 **New Apify users get $5 in free credits** — enough to scrape up to 10,000 actors on your first try.

Apify Store Scraper **does not use proxies or browser rendering** — it calls the Apify Store's public search API directly. This makes runs extremely fast (typically under 10 seconds for 100 results) and very cheap to operate.

***

### Apify platform advantages

By running **Apify Store Scraper** on the Apify platform, you get all of these for free:

- ⏱️ **Scheduling** — run on a daily, weekly, or custom cron schedule to monitor the Store over time
- 🔌 **API access** — trigger runs and retrieve data programmatically via the Apify API
- 🔗 **Integrations** — connect directly with Google Sheets, Zapier, Make, Slack, Airbyte, and more
- 📦 **Export formats** — download results as JSON, CSV, XML, Excel, or HTML
- 📡 **Webhooks** — trigger actions automatically when a run completes
- 📊 **Run monitoring** — track performance, logs, and history from the Apify Console
- 🔒 **Secure storage** — your datasets are stored securely and available on demand

***

### Is it legal to scrape the Apify Store?

**Apify Store Scraper** only accesses **publicly available data** from the Apify Store marketplace — the same data you can see by visiting [apify.com/store](https://apify.com/store) in any browser.

This scraper does not extract any private user data, passwords, email addresses, or any information not explicitly displayed on the public Store pages. We therefore believe that using this scraper for ethical research, market analysis, or tool discovery purposes is safe.

However, you are responsible for how you use the extracted data. Personal data (such as developer names and profile pictures that are publicly listed) is protected under GDPR in the European Union and other regulations worldwide. Use data responsibly and in compliance with applicable laws. If in doubt, consult your legal team.

***

### Frequently asked questions

#### Does Apify Store Scraper work without an Apify account?

No — you need a free Apify account to run actors on the platform. Creating one takes less than a minute and gives you **$5 in free credits** to get started.

#### How many actors are available on the Apify Store?

The Apify Store has **24,000+ public actors**, with new ones being added every day. Set `maxItems` to `25000` and `sortBy` to `newest` to track the latest additions.

#### Can I filter actors by multiple categories at once?

Yes. Set the `categories` input to an array with multiple values, for example `["AI", "SOCIAL_MEDIA", "ECOMMERCE"]`. Results will include actors that match **any** of the selected categories.

#### Can I get all actors from a specific developer?

Yes — use the `username` input field with the developer's Apify username. For example, setting `username` to `"apify"` returns all actors published by Apify's official team.

#### What is the difference between `APIFY` and `COMMUNITY` in the `managedBy` filter?

- `APIFY` — actors built and maintained by the Apify team (218 actors total)
- `COMMUNITY` — actors built by independent developers (24,000+ actors — the vast majority of the Store)

#### What pricing models exist in the Apify Store?

Based on live Store data, three models are used:

- `FREE` — no cost beyond standard platform usage
- `PAY_PER_EVENT` — pay per result extracted (most common: ~51% of the Store)
- `FLAT_PRICE_PER_MONTH` — fixed monthly subscription (~36% of the Store)

#### How do I get only free actors?

Set `pricingModel` to `["FREE"]`. This returns all actors that have no cost beyond standard Apify platform usage.

#### Can I scrape Apify Store data via API?

Yes. Once you have an Apify account, you can trigger this Actor and retrieve results via the [Apify API](https://docs.apify.com/api/v2). The API tab on this page shows ready-to-use code examples in Node.js, Python, and cURL.

#### How often is the Apify Store data updated?

The data reflects the live state of the Apify Store at the time of each run. Schedule the Actor to run daily or weekly to capture changes over time.

***

### Support

Found a bug or want a new feature? Open a ticket on the **Issues tab** above — I read and respond to all feedback.

For custom data extraction needs or integrations, feel free to reach out through the Issues tab.

# Actor input Schema

## `query` (type: `string`):

Text to search across actor titles, names, descriptions, and README files. Leave empty to return all actors.

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

Maximum number of actors to extract. The Apify Store has 24,000+ actors — set to 25000 to get the full catalog.

## `sortBy` (type: `string`):

How to order the results.

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

Filter by one or more categories. Results include actors matching ANY of the selected categories.

## `pricingModel` (type: `array`):

Filter by pricing model. Results include actors matching ANY of the selected models.

## `managedBy` (type: `string`):

Filter by who maintains the actor.

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

Filter actors by a specific developer's Apify username.

## `actorId` (type: `string`):

Fetch a specific actor by its unique Apify ID.

## `minRating` (type: `number`):

Only include actors with an average rating equal to or above this value (1–5 scale).

## `minUsers` (type: `integer`):

Only include actors with at least this many total users.

## `minBookmarks` (type: `integer`):

Only include actors with at least this many bookmarks.

## Actor input object example

```json
{
  "query": "instagram scraper",
  "maxItems": 100,
  "sortBy": "relevance",
  "managedBy": "ALL",
  "username": "apify",
  "actorId": "aYG0l9s7dbB7j3gbS",
  "minRating": 4,
  "minUsers": 100,
  "minBookmarks": 10
}
```

# 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 = {
    "query": "instagram scraper",
    "maxItems": 100,
    "username": "apify",
    "actorId": "aYG0l9s7dbB7j3gbS",
    "minRating": 4,
    "minUsers": 100,
    "minBookmarks": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("extractmaster01/apify-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 = {
    "query": "instagram scraper",
    "maxItems": 100,
    "username": "apify",
    "actorId": "aYG0l9s7dbB7j3gbS",
    "minRating": 4,
    "minUsers": 100,
    "minBookmarks": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("extractmaster01/apify-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 '{
  "query": "instagram scraper",
  "maxItems": 100,
  "username": "apify",
  "actorId": "aYG0l9s7dbB7j3gbS",
  "minRating": 4,
  "minUsers": 100,
  "minBookmarks": 10
}' |
apify call extractmaster01/apify-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apify Store Scraper",
        "description": "Extract actor data from Apify Store using the official search API. Filter by category, pricing model, developer or keyword. Sort by popularity, newest or last updated. Get titles, stats, pricing, ratings and categories for any actor.",
        "version": "0.0",
        "x-build-id": "ajqK00d3yy3IsJbUF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/extractmaster01~apify-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-extractmaster01-apify-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/extractmaster01~apify-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-extractmaster01-apify-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/extractmaster01~apify-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-extractmaster01-apify-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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Text to search across actor titles, names, descriptions, and README files. Leave empty to return all actors."
                    },
                    "maxItems": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 25000,
                        "type": "integer",
                        "description": "Maximum number of actors to extract. The Apify Store has 24,000+ actors — set to 25000 to get the full catalog.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "mostPopular",
                            "newest",
                            "lastUpdated"
                        ],
                        "type": "string",
                        "description": "How to order the results.",
                        "default": "relevance"
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Filter by one or more categories. Results include actors matching ANY of the selected categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AI",
                                "AGENTS",
                                "AUTOMATION",
                                "BUSINESS",
                                "DEVELOPER_TOOLS",
                                "EDUCATION",
                                "ECOMMERCE",
                                "FOR_CREATORS",
                                "INTEGRATIONS",
                                "JOBS",
                                "LEAD_GENERATION",
                                "MARKETING",
                                "MCP_SERVERS",
                                "NEWS",
                                "OPEN_SOURCE",
                                "OTHER",
                                "REAL_ESTATE",
                                "SEO_TOOLS",
                                "SOCIAL_MEDIA",
                                "SPORTS",
                                "TRAVEL",
                                "VIDEOS"
                            ],
                            "enumTitles": [
                                "AI",
                                "Agents",
                                "Automation",
                                "Business",
                                "Developer Tools",
                                "Education",
                                "E-commerce",
                                "For Creators",
                                "Integrations",
                                "Jobs",
                                "Lead Generation",
                                "Marketing",
                                "MCP Servers",
                                "News",
                                "Open Source",
                                "Other",
                                "Real Estate",
                                "SEO Tools",
                                "Social Media",
                                "Sports",
                                "Travel",
                                "Videos"
                            ]
                        }
                    },
                    "pricingModel": {
                        "title": "Pricing Model",
                        "type": "array",
                        "description": "Filter by pricing model. Results include actors matching ANY of the selected models.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "FREE",
                                "PAY_PER_EVENT",
                                "PRICE_PER_DATASET_ITEM",
                                "PAY_PER_USAGE",
                                "FLAT_PRICE_PER_MONTH"
                            ],
                            "enumTitles": [
                                "Free",
                                "Pay Per Event",
                                "Pay Per Result",
                                "Pay Per Usage",
                                "Monthly Flat Rate (deprecated)"
                            ]
                        }
                    },
                    "managedBy": {
                        "title": "Maintained By",
                        "enum": [
                            "ALL",
                            "APIFY",
                            "COMMUNITY"
                        ],
                        "type": "string",
                        "description": "Filter by who maintains the actor.",
                        "default": "ALL"
                    },
                    "username": {
                        "title": "Developer Username",
                        "type": "string",
                        "description": "Filter actors by a specific developer's Apify username."
                    },
                    "actorId": {
                        "title": "Actor ID",
                        "type": "string",
                        "description": "Fetch a specific actor by its unique Apify ID."
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include actors with an average rating equal to or above this value (1–5 scale)."
                    },
                    "minUsers": {
                        "title": "Minimum Total Users",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include actors with at least this many total users."
                    },
                    "minBookmarks": {
                        "title": "Minimum Bookmarks",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include actors with at least this many bookmarks."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
