# AlternativeTo Scraper | Software Alternatives Database (`parseforge/alternativeto-scraper`) Actor

Pull software alternatives from AlternativeTo with app name, platforms, license, pricing, features, tags, ratings, reviews, and competing tools. Build software directories, comparison sites, lead lists, and product research datasets for SaaS, open source, and tech markets.

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

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔀 AlternativeTo Scraper

> 🚀 **Export software alternatives, likes, platforms, and license data from AlternativeTo in seconds.** No API key required.

> 🕒 **Last updated:** 2026-05-21 - **📊 16 fields** per record - **100+ alternatives per software** - **Global coverage**

The AlternativeTo Scraper lets you extract the full list of software alternatives from [alternativeto.net](https://alternativeto.net) for any software product. Search by software name (e.g. "slack", "notion", "figma") and get structured data on every alternative including likes, supported platforms, license types, and whether the tool is free or open source.

AlternativeTo is the web's largest crowd-sourced software comparison database, listing over 300,000 software alternatives across every category. This actor delivers that data in clean, structured JSON - ready for analysis, comparison, or integration into your own tools.

**Coverage:** Alternatives to 300,000+ software products - 16 data fields per record - Mac, Windows, Linux, Android, iPhone, Web-based, Self-Hosted, and more - open source and commercial tools alike.

---

### Target Audience / Use Cases

| Who | What They Build |
|-----|-----------------|
| Product managers | Competitive landscape maps for any tool |
| Developers | Open-source alternative discovery pipelines |
| Researchers | Software ecosystem analysis and category mapping |
| Marketers | Positioning benchmarks and feature comparison tables |
| Venture capitalists | Market sizing and competitive density analysis |
| Enterprise buyers | Vendor shortlist generation by platform and license |

---

### 📋 What the AlternativeTo Scraper does

- Searches AlternativeTo for all alternatives to any named software product
- Returns each alternative's name, slug, description, and canonical URL
- Extracts the number of likes (crowd-sourced ranking signal)
- Lists all supported platforms: Mac, Windows, Linux, Android, iPhone, Web, Self-Hosted, etc.
- Lists license/pricing types: Free, Freemium, Open Source, Paid, Proprietary, etc.
- Detects whether each alternative is open source or has a free tier
- Exports the official website link where available
- Paginates automatically to collect all alternatives up to your requested limit
- Returns data in JSON, CSV, Excel, or XML

> 💡 **Why it matters:** Most software evaluation happens through expensive analyst reports or manual research. AlternativeTo aggregates real user votes across 300,000+ software products. This actor gives you programmatic access to that intelligence at scale.

---

### 🎬 Full Demo

🚧 Coming soon

---

### ⚙️ Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `softwareName` | string | Yes | `slack` | The software name or slug to find alternatives for (e.g. `notion`, `figma`, `jira`) |
| `maxItems` | integer | No | `10` | Maximum number of results. Free users: limited to 10. Paid users: up to 1,000,000. |

**Example - Find alternatives to Slack:**
```json
{
    "softwareName": "slack",
    "maxItems": 50
}
````

**Example - Find alternatives to Notion:**

```json
{
    "softwareName": "notion",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** Use the URL slug for best results. For example, for "Microsoft Teams" use `microsoft-teams`, not `Teams`. The slug is the part after `alternativeto.net/software/` in the URL. Simple one-word names like `slack`, `notion`, `figma` work directly.

***

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | High-resolution app icon URL (280px) |
| 📌 `name` | string | Name of the alternative software |
| 🔗 `url` | string | AlternativeTo page URL |
| 🔤 `slug` | string | Software slug used in AlternativeTo URLs |
| 📝 `description` | string | Short crowd-sourced description |
| ❤️ `likes` | integer | Number of user likes on AlternativeTo |
| 💬 `comments` | integer | Number of comments (null - not available in listing) |
| 💻 `platforms` | array | Supported platforms (Mac, Windows, Linux, Android, etc.) |
| 📜 `licenses` | array | License/pricing types (Free, Open Source, Freemium, etc.) |
| 🏷 `category` | string | Software category (e.g. Social & Communications) |
| 🔓 `isOpenSource` | boolean | Whether the software is open source |
| 🆓 `isFree` | boolean | Whether the software has a free tier |
| 🔀 `alternativeTo` | string | The software name this is an alternative to |
| 🌐 `website` | string | Official website URL (when available) |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp |
| ❌ `error` | string | Error message if scraping failed |

**Sample records:**

```json
[
  {
    "imageUrl": "https://img.alternativeto.net/icons/280/element-app_245901.svg",
    "name": "Element",
    "url": "https://alternativeto.net/software/element-app/",
    "slug": "element-app",
    "description": "Provides secure collaboration with end-to-end encryption, supporting chat, voice, and video calls. Available on all major platforms, it enables digital sovereignty with a decentralized design and interoperability through bridges to systems like Slack and Teams. Includes enterprise-grade SaaS.",
    "likes": 815,
    "comments": null,
    "platforms": ["Mac", "Windows", "Linux", "Online", "Android", "iPhone", "Android Tablet", "iPad", "Self-Hosted", "Snapcraft", "Matrix.org", "Flathub", "F-Droid", "Cloudron"],
    "licenses": ["Free Personal", "Open Source"],
    "category": "Social & Communications",
    "isOpenSource": true,
    "isFree": true,
    "alternativeTo": "slack",
    "website": null,
    "scrapedAt": "2026-05-22T01:44:21.947Z",
    "error": null
  },
  {
    "imageUrl": "https://img.alternativeto.net/icons/280/zulip-chat-server_251998.svg",
    "name": "Zulip",
    "url": "https://alternativeto.net/software/zulip-chat-server/",
    "slug": "zulip-chat-server",
    "description": "Threaded group conversations combine live and asynchronous messaging, separating topics for organized collaboration, supporting open-source, cloud, and self-hosted deployments, secure communication with encryption, and multi-platform access for diverse teams.",
    "likes": 271,
    "comments": null,
    "platforms": ["Mac", "Windows", "Linux", "Online", "Android", "iPhone", "Android Tablet", "BSD", "iPad", "Self-Hosted", "F-Droid"],
    "licenses": ["Free Personal", "Open Source"],
    "category": "Social & Communications",
    "isOpenSource": true,
    "isFree": true,
    "alternativeTo": "slack",
    "website": null,
    "scrapedAt": "2026-05-22T01:44:21.948Z",
    "error": null
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🔓 No API key needed | Works out of the box, no registration required |
| 🌐 Real browser scraping | Bypasses Cloudflare protection reliably |
| 🔀 Search any software | Works for 300,000+ software products on AlternativeTo |
| 💻 Full platform list | Extracts every supported platform per alternative |
| 📜 License detection | Automatically flags open source and free tools |
| ❤️ Likes ranking | Get crowd-sourced popularity signals |
| 📦 Paginated | Collects all results, not just the first page |
| 🚀 Apify proxy | Residential proxy rotation built in |

***

### 📈 How it compares to alternatives

| Feature | This Actor | Manual Research | AlternativeTo UI |
|---------|-----------|-----------------|-----------------|
| Programmatic access | Yes | No | No |
| Bulk export | Yes | No | No |
| Structured JSON/CSV | Yes | No | No |
| All platforms listed | Yes | Manual | Yes |
| License detection | Yes | Manual | Yes |
| Pagination | Yes | Manual | Yes |
| Free tier | 10 items | Unlimited | Unlimited |

***

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (includes $5 free credit)
2. Open the [AlternativeTo Scraper](https://apify.com/parseforge/alternativeto-scraper) actor page
3. Enter the software name you want alternatives for (e.g. `slack`, `notion`, `figma`)
4. Set `maxItems` to control how many results you need
5. Click **Start** and wait for the run to complete
6. Download results as JSON, CSV, Excel, or XML from the dataset tab

***

### 💼 Business use cases

#### Competitive Intelligence

Track what alternatives users recommend to your product on AlternativeTo. Monitor likes trends over time. Identify which features competitors emphasize in their descriptions. Build a real-time competitive radar.

#### Open Source Discovery

Filter by `isOpenSource: true` to find every open-source alternative to commercial tools. Evaluate self-hosted options. Build curated lists for developer communities or internal tooling decisions.

#### Market Research & Product Strategy

Map the software landscape for any category. Count how many alternatives exist, what platforms they support, what licensing models dominate. Use data to identify whitespace and market positioning opportunities.

#### Vendor Evaluation & Procurement

Automatically generate shortlists of alternatives to tools your organization already uses. Filter by platform requirements (Self-Hosted, Windows, etc.) and licensing constraints (Open Source, Free). Speed up vendor selection.

***

### 🔌 Automating AlternativeTo Scraper

Integrate this actor into your workflows using the Apify platform:

- **Make (Integromat):** Trigger the actor on a schedule, send results to Google Sheets or Airtable
- **Zapier:** Connect actor runs to Slack notifications, Notion databases, or CRM systems
- **Apify Scheduler:** Run automatically every week to track new alternatives
- **Apify API:** Call directly from your application using the REST API
- **Webhooks:** Get notified via HTTP when a run completes

***

### 🌟 Beyond business use cases

#### Academic Research

Study software ecosystem evolution. Analyze open-source adoption rates across categories. Map platform support trends over time.

#### Creative Projects

Build your own alternative finder app. Create curated technology stacks for specific use cases. Generate comparison articles with real data.

#### Non-Profit Use

Identify free and open-source alternatives to expensive tools for budget-constrained organizations, schools, and NGOs.

#### Experimentation

Test hypotheses about software markets. Which categories have the most alternatives? Which platforms are underserved? What license models dominate in each category?

***

### 🤖 Ask an AI assistant about this scraper

Want to understand what this scraper can do for your specific use case? Paste this into your favorite AI assistant:

> "I have access to the ParseForge AlternativeTo Scraper on Apify, which can extract software alternatives for any product including name, URL, description, likes, platforms, licenses, isOpenSource, and isFree. I want to \[describe your goal]. How can I use this data?"

***

### ❓ Frequently Asked Questions

#### 🔍 What software names can I search for?

Any software listed on AlternativeTo. Use the slug from the URL - e.g., for `https://alternativeto.net/software/microsoft-teams/`, the slug is `microsoft-teams`. Simple names like `slack`, `notion`, `figma`, `zoom`, `jira` work directly.

#### 📊 How many alternatives are there per software?

Varies by popularity. Slack has 100+ alternatives. Niche tools may have 5-20. The actor paginates automatically to collect all available alternatives.

#### ❤️ What is the "likes" field?

On AlternativeTo, users vote to say "this is a good alternative to X." The likes count reflects crowd-sourced popularity. Higher likes = more users recommend it as an alternative.

#### 💬 Why are comments null?

Comment counts require fetching individual item UUIDs that are only available through a private API endpoint. The listing page shows likes but not comments in an accessible format. This field is reserved for future implementation.

#### 🔓 How does "isOpenSource" detection work?

The actor reads the "Cost / License" section on each card. If any license tag contains "Open Source," `isOpenSource` is set to `true`.

#### 🆓 How does "isFree" detection work?

Any license tag containing "Free" (including "Free Personal," "Freemium," "Free") sets `isFree` to `true`. Purely paid/proprietary tools get `isFree: false`.

#### 🌐 When is the "website" field populated?

For sponsored/featured listings, AlternativeTo shows an external link. For regular listings, no direct website link is shown on the listing page. The actor captures the external link when present.

#### 💻 What platforms are listed?

AlternativeTo lists platforms like Mac, Windows, Linux, Online (web-based), Android, iPhone, Android Tablet, iPad, Self-Hosted, BSD, and many technology-specific tags (JavaScript, Go, Snapcraft, F-Droid, Cloudron, etc.).

#### 🛡️ Is this scraper reliable?

The actor uses a real Firefox browser with residential proxies to reliably bypass Cloudflare protection on AlternativeTo. Runs are stable across thousands of items.

#### 💰 How much does it cost?

Free users get 10 items per run. [Paid users](https://console.apify.com/sign-up?fpr=vmoqkp) can extract up to 1,000,000 items. Typical runs use minimal compute - costs are very low.

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

Yes. Use Apify's built-in scheduler to run the actor on a recurring basis and track new alternatives over time.

#### 📁 What export formats are supported?

JSON, CSV, Excel (XLSX), XML, and JSONL. Download from the Apify Console dataset tab or via the API.

***

### 🔌 Integrate with any app

Connect the AlternativeTo Scraper to your favorite tools:

| App | Use Case |
|-----|----------|
| Google Sheets | Automatic spreadsheet with all alternatives |
| Airtable | Database of competitive alternatives |
| Notion | Research database for product teams |
| Slack | Notify your team when new alternatives appear |
| Make (Integromat) | Multi-step automation workflows |
| Zapier | No-code integrations with 5,000+ apps |
| REST API | Direct programmatic access |
| Webhooks | Event-driven notifications |

***

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [ParseForge NPM Registry Scraper](https://apify.com/parseforge/npm-registry-scraper) | Extract package data, download counts, and metadata from the NPM registry |
| [ParseForge PyPI Scraper](https://apify.com/parseforge/pypi-scraper) | Scrape Python package details, stats, and metadata from PyPI |
| [ParseForge GitHub Trending Scraper](https://apify.com/parseforge/github-trending-scraper) | Scrape trending repositories from GitHub by language and time period |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) on the Apify Store for more data extraction tools across every category.

***

*Disclaimer: This actor is an independent tool and is not affiliated with, endorsed by, or associated with AlternativeTo or its parent company. Data is scraped from publicly available web pages. Use responsibly and in accordance with AlternativeTo's Terms of Service.*

# Actor input Schema

## `softwareName` (type: `string`):

The name or slug of the software to find alternatives for (e.g. 'slack', 'notion', 'figma').

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "softwareName": "slack",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "softwareName": "slack",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/alternativeto-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 = {
    "softwareName": "slack",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/alternativeto-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 '{
  "softwareName": "slack",
  "maxItems": 10
}' |
apify call parseforge/alternativeto-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AlternativeTo Scraper | Software Alternatives Database",
        "description": "Pull software alternatives from AlternativeTo with app name, platforms, license, pricing, features, tags, ratings, reviews, and competing tools. Build software directories, comparison sites, lead lists, and product research datasets for SaaS, open source, and tech markets.",
        "version": "0.1",
        "x-build-id": "wkVGu7jaIg6QPW9n1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~alternativeto-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-alternativeto-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/parseforge~alternativeto-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-alternativeto-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/parseforge~alternativeto-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-alternativeto-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "softwareName"
                ],
                "properties": {
                    "softwareName": {
                        "title": "Software Name",
                        "type": "string",
                        "description": "The name or slug of the software to find alternatives for (e.g. 'slack', 'notion', 'figma')."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
