# AITools.fyi Scraper (`automation-lab/aitools-fyi-scraper`) Actor

Scrape 13,500+ AI tools from aitools.fyi: name, category, pricing, description, tags, website, and more

- **URL**: https://apify.com/automation-lab/aitools-fyi-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## AITools.fyi Scraper

Extract data on 13,500+ AI tools from [aitools.fyi](https://aitools.fyi) — the popular AI tools directory. Get tool names, descriptions, categories, pricing types, tags, features, pros/cons, FAQs, websites, and more with a single actor run.

No API key required. No login needed. Just run and get data.

### What does it do?

AITools.fyi Scraper crawls the aitools.fyi directory and extracts structured data for every AI tool listed. It reads tool pages directly from the website HTML (using `__NEXT_DATA__` embedded JSON) and returns rich, clean records — no browser automation needed.

🔍 **Discover AI tools by category** — filter by image generation, productivity, chatbots, code assistants, marketing, education, and 70+ more categories.

📦 **Export the full directory** — scrape all 13,500+ tools to build your own AI tools database, research corpus, or competitive analysis report.

🔗 **Fetch specific tools** — provide a list of aitools.fyi URLs to extract data for a curated set of tools.

### Who is it for?

This actor is built for:

- **AI researchers and analysts** who want to track AI tool trends, pricing models, category distributions, and feature sets across the entire AI ecosystem.
- **Product managers and founders** benchmarking competitors in the AI space or discovering new tools to evaluate.
- **Data journalists** writing about AI tool adoption, pricing shifts, or category growth.
- **Developers building AI tool directories** who need a seed dataset or want to keep a local database in sync with aitools.fyi.
- **Marketers** researching the competitive landscape before launching an AI product.
- **Investors and VCs** doing market mapping across specific AI verticals (e.g., all code assistants, all video generators).

### Why use this actor?

✅ **No login required** — data is publicly available and embedded in every tool page.

✅ **Rich data per tool** — description, tags, tech stack, top features, FAQs, social links, app store links, and more.

✅ **Category filtering** — scrape only the tools you care about (e.g., all image generation tools) without fetching the entire directory.

✅ **Scale from 1 to 13,500+ tools** — set `maxItems` to control cost and run time.

✅ **Deduplication built in** — every tool is returned once even if it appears in multiple categories.

✅ **Up-to-date** — scrapes live from the website, so you always get the latest tool entries.

### Data extracted

Each tool record contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `id` | Number | Internal tool ID on aitools.fyi |
| `name` | String | Tool name |
| `slug` | String | URL slug (e.g., `chatgpt`) |
| `url` | String | Full aitools.fyi URL |
| `website` | String | Official tool website |
| `pricingType` | String | Pricing model: Free, Freemium, Paid, or Contact for Pricing |
| `category` | String | Primary category name |
| `categorySlug` | String | Category slug for filtering |
| `description` | String | Full English description of the tool |
| `tags` | String[] | Keyword tags associated with the tool |
| `techUsed` | String[] | Technologies the tool uses (e.g., GPT-4, Stable Diffusion) |
| `topFeatures` | String[] | Highlighted feature list (up to 5 items) |
| `pros` | String | Pros summary (when available) |
| `cons` | String | Cons summary (when available) |
| `faqs` | Object[] | Q&A pairs from the tool page |
| `socialLinks` | Object | Social media links (Twitter, LinkedIn, etc.) |
| `appStoreLink` | String | iOS App Store link (when available) |
| `playStoreLink` | String | Google Play Store link (when available) |
| `updatedAt` | String | Last updated timestamp (ISO 8601) |

### Pricing — how much does it cost to scrape AI tool listings from aitools.fyi?

This actor uses **pay-per-result** (PPE) pricing. You pay only for tools successfully extracted.

| Plan | Price per tool |
|------|---------------|
| FREE | $0.000035 / tool |
| BRONZE | $0.000031 / tool |
| SILVER | $0.000024 / tool |
| GOLD | $0.000018 / tool |
| PLATINUM | $0.000012 / tool |
| DIAMOND | $0.0000086 / tool |

Plus a one-time **start fee of $0.005 per run** (covers the actor initialization cost).

**Example cost estimates:**
- 100 tools → ~$0.008 (start + 100 results at BRONZE)
- 1,000 tools → ~$0.036 at BRONZE
- 13,500 tools (full directory) → ~$0.42 at BRONZE, ~$0.12 at DIAMOND

🆓 **Free tier users** can extract the full 13,500+ tool directory up to **10 times per month** at no cost using Apify's monthly free compute credits ($5/month).

### How to use

#### Step 1 — Open the actor
Go to the [AITools.fyi Scraper](https://apify.com/automation-lab/aitools-fyi-scraper) page on the Apify Store.

#### Step 2 — Configure input

**Option A: Scrape all tools (no filter)**
Leave `categories` and `startUrls` empty. Set `maxItems` to control how many tools to extract.

**Option B: Filter by category**
Enter category slugs in the `categories` field. Find slugs in aitools.fyi URLs (e.g., the URL `/category/image-generation` → slug is `image-generation`).

**Option C: Fetch specific tools**
Add aitools.fyi tool URLs to `startUrls` (e.g., `https://aitools.fyi/chatgpt`).

#### Step 3 — Run and download
Click **Start** and wait for the run to finish. Download results as JSON, CSV, or Excel from the **Dataset** tab.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | String[] | `[]` | Category slugs to filter (e.g., `image-generation`, `productivity`). Empty = all categories. |
| `startUrls` | URL[] | `[]` | Specific aitools.fyi tool URLs. Overrides category filter. |
| `maxItems` | Integer | `100` | Max tools to extract. Set to `0` for no limit. |
| `maxRequestRetries` | Integer | `2` | Retry attempts for failed HTTP requests. |
| `requestTimeoutSecs` | Integer | `20` | Timeout per HTTP request in seconds. |

### Output format

Each extracted tool is stored as a JSON object in the default dataset. Example:

```json
{
  "id": 12345,
  "name": "Example AI Tool",
  "slug": "example-ai-tool",
  "url": "https://aitools.fyi/example-ai-tool",
  "website": "https://example.com",
  "pricingType": "Freemium",
  "category": "Image Generation",
  "categorySlug": "image-generation",
  "description": "Example AI Tool is an AI-powered...",
  "tags": ["image generation", "AI art", "creative"],
  "techUsed": ["Stable Diffusion", "CLIP"],
  "topFeatures": [
    "🎨 Generate images from text prompts",
    "🖼️ Style transfer and inpainting",
    "⚡ Fast generation under 5 seconds"
  ],
  "pros": "Easy to use, great output quality",
  "cons": "Limited free tier",
  "faqs": [
    {
      "question": "Is there a free plan?",
      "answer": "Yes, we offer 10 free credits per day."
    }
  ],
  "socialLinks": { "twitter": "https://twitter.com/exampletool" },
  "appStoreLink": null,
  "playStoreLink": null,
  "updatedAt": "2025-10-15T12:00:00Z"
}
````

### Tips and tricks

💡 **Use category slugs from URLs** — visit `https://aitools.fyi/category/image-generation` and the slug is the last URL path segment (`image-generation`).

💡 **Start small to preview data** — set `maxItems: 10` for a quick test before running the full directory.

💡 **Combine with Google Sheets** — use Apify's Google Sheets integration to automatically sync extracted AI tools to a spreadsheet.

💡 **Schedule daily updates** — use Apify Schedules to run the actor daily and get the latest additions to the directory.

💡 **Category filtering works by matching** — categories are matched by slug (e.g., `chat-bot`) or name (case-insensitive). Check the aitools.fyi category page URL for the correct slug.

💡 **Zero limit = full scrape** — set `maxItems: 0` to scrape all tools. This runs for longer but gives you the complete directory.

### Integrations

#### Export to Google Sheets

Use the built-in **Google Sheets** integration to automatically send extracted AI tools to a spreadsheet — perfect for shared research with a team.

#### Zapier / Make automation

Connect this actor to Zapier or Make and trigger workflows when new AI tools are scraped — e.g., add rows to Airtable, send Slack notifications for new tools in your category of interest.

#### Build an AI tool comparison app

Use the extracted data (features, pricing, tags) to power a custom comparison UI or recommendation engine.

#### Market research pipelines

Schedule weekly scrapes of specific categories (e.g., `video-generation`) and feed results into a data warehouse (BigQuery, Snowflake) for trend tracking.

#### Competitive intelligence

Monitor specific tools by URL and alert when description, features, or pricing type changes (compare with previous dataset).

### API usage

#### Node.js (Apify SDK)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/aitools-fyi-scraper').call({
  categories: ['image-generation'],
  maxItems: 100,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/aitools-fyi-scraper').call(run_input={
    'categories': ['image-generation'],
    'maxItems': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['name'], item['pricingType'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~aitools-fyi-scraper/runs' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"categories": ["productivity"], "maxItems": 50}'
```

### Use with AI assistants (MCP)

This actor is available as an **MCP (Model Context Protocol) tool**, making it directly accessible from AI assistants like Claude Code, Claude Desktop, and VS Code Copilot.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/aitools-fyi-scraper"
```

Then in Claude Code:

```
Search aitools.fyi for all image generation tools with their pricing and features
```

#### Claude Desktop / VS Code / Cursor

Add to your MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/aitools-fyi-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

**Example prompts for AI assistants:**

- "Scrape the top 50 AI productivity tools from aitools.fyi and summarize their pricing types"
- "Get all AI video generation tools and list their top features"
- "Fetch data for chatgpt, midjourney, and perplexity-ai from aitools.fyi"

### Legality and terms of service

The data scraped by this actor is publicly available on [aitools.fyi](https://aitools.fyi) and does not require login or authentication. The actor reads data embedded in page HTML without circumventing any access controls.

Web scraping publicly available data for research, analysis, and personal use is generally lawful in most jurisdictions. Review aitools.fyi's [Terms of Service](https://aitools.fyi/terms) and [Privacy Policy](https://aitools.fyi/privacy) before use at scale. Always use responsibly — don't overload the target website.

This actor is not affiliated with or endorsed by aitools.fyi.

### FAQ

**Q: How many tools does aitools.fyi have?**
A: As of 2025, aitools.fyi lists over 13,500 AI tools across 77+ categories. The directory grows regularly.

**Q: How long does a full scrape take?**
A: Scraping all 13,500 tools takes approximately 30–60 minutes depending on server response times. For 100 tools, expect under 2 minutes.

**Q: The actor returns fewer tools than maxItems — why?**
A: This can happen when filtering by category and the category has fewer tools than `maxItems`, or when some tool pages return errors. Check the logs for warnings about failed pages.

**Q: Some tools have null pros/cons/FAQs — is that normal?**
A: Yes. Not all tool listings on aitools.fyi include pros, cons, or FAQ sections. These fields are `null` when the tool page doesn't have them.

**Q: My category filter isn't matching any tools. What's wrong?**
A: Use the exact slug from the aitools.fyi URL, not the display name. For example, use `chat-bot` (not `chatbots` or `Chatbots`). Check the URL when browsing a category page.

**Q: Can I scrape tools in languages other than English?**
A: The actor extracts the English description by default. The tool pages also include French, Spanish, Portuguese, and Chinese descriptions — contact us if you need multi-language output.

**Q: The website structure changed and data is missing — what do I do?**
A: Open an issue on the Apify forum. We monitor aitools.fyi for structural changes and update the actor accordingly.

### Related actors

- [Apify Store Scraper](https://apify.com/automation-lab/apify-store-scraper) — Scrape Apify actor listings for pricing, categories, and metadata.
- [Product Hunt Scraper](https://apify.com/automation-lab/product-hunt-scraper) — Extract product launches and maker details from Product Hunt.
- [G2 Reviews Scraper](https://apify.com/automation-lab/g2-reviews-scraper) — Scrape software reviews and ratings from G2.

# Actor input Schema

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

List of category slugs to scrape (e.g. 'image-generation', 'productivity', 'chatbots'). Leave empty to scrape all categories from the sitemap.

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

Specific aitools.fyi tool URLs to scrape (e.g. 'https://aitools.fyi/chatgpt'). Overrides category filtering when provided.

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

Maximum number of tools to extract. Set to 0 for no limit (scrapes the full directory).

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

## `requestTimeoutSecs` (type: `integer`):

Timeout in seconds for each HTTP request.

## Actor input object example

```json
{
  "categories": [],
  "startUrls": [],
  "maxItems": 20,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 20
}
```

# 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 = {
    "categories": [],
    "startUrls": [],
    "maxItems": 20,
    "maxRequestRetries": 3,
    "requestTimeoutSecs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/aitools-fyi-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 = {
    "categories": [],
    "startUrls": [],
    "maxItems": 20,
    "maxRequestRetries": 3,
    "requestTimeoutSecs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/aitools-fyi-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 '{
  "categories": [],
  "startUrls": [],
  "maxItems": 20,
  "maxRequestRetries": 3,
  "requestTimeoutSecs": 20
}' |
apify call automation-lab/aitools-fyi-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AITools.fyi Scraper",
        "description": "Scrape 13,500+ AI tools from aitools.fyi: name, category, pricing, description, tags, website, and more",
        "version": "0.1",
        "x-build-id": "gcZpMABCdygXlfkAY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~aitools-fyi-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-aitools-fyi-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~aitools-fyi-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-aitools-fyi-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~aitools-fyi-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-aitools-fyi-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": {
                    "categories": {
                        "title": "📂 Categories to scrape",
                        "type": "array",
                        "description": "List of category slugs to scrape (e.g. 'image-generation', 'productivity', 'chatbots'). Leave empty to scrape all categories from the sitemap.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🔗 Specific tool URLs",
                        "type": "array",
                        "description": "Specific aitools.fyi tool URLs to scrape (e.g. 'https://aitools.fyi/chatgpt'). Overrides category filtering when provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max tools",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of tools to extract. Set to 0 for no limit (scrapes the full directory).",
                        "default": 100
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout in seconds for each HTTP request.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
