# n8n Workflow Templates Scraper (`solidcode/n8n-workflow-templates-scraper`) Actor

\[💰 $4 / 1K] Extract n8n workflow automation templates — name, description, author, views, apps used, and the full importable workflow blueprint. Search by keyword and filter by category or integration.

- **URL**: https://apify.com/solidcode/n8n-workflow-templates-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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

## n8n Workflow Templates Scraper

Pull ready-made automations from the public n8n.io template catalog at scale — title, description, author, view count, the exact apps each workflow wires together, and the full importable node-graph blueprint. Search by keyword, narrow to any of 7 categories, filter by any of 422 integrations, and sort by all-time views or newest. Built for automation builders, no-code agencies, and RPA teams who need a structured library of proven n8n workflows without opening and copying each template by hand.

### Why This Scraper?

- **The complete ~10,000-template catalog** — browse the entire public n8n.io library in one run, or cap each query to the exact number of templates you want with `maxResults`.
- **Full importable workflow blueprint** — flip `includeWorkflowJson` on and every row carries the runnable node graph, node parameters, and step-to-step connections you can import straight into n8n. The competing scraper never fetches this.
- **7 category filters** — AI, Sales, IT Ops, Marketing, Document Ops, Support, and Other, matching n8n's own catalog tabs exactly.
- **422 integration filters** — pull only the workflows that use Slack, OpenAI, Google Sheets, Notion, Telegram, Gmail, Postgres, Discord, or any other app by name.
- **Sort by all-time views or newest first** — surface the most-proven automations, or catch what creators published this week.
- **Every app in every workflow, named** — each row lists the integrations the template chains together plus a `nodeCount`, so you can see a workflow's shape before you open it.
- **Creator profiles attached** — author name, username, bio, avatar, verified-creator flag, and profile links come with every template for outreach and attribution.
- **Keyword search plus direct template links** — search free-text queries like "invoice OCR" or paste specific `n8n.io/workflows/1234` URLs; both work in the same run.

### Use Cases

**Automation Research**
- Discover the most-viewed workflows for a given app or use case
- Track what n8n creators are publishing week over week with newest-first sorting
- Benchmark how many nodes typical workflows in a category use
- Map which integrations pair together most often across the catalog

**Building a Template Library**
- Assemble a curated internal library of proven workflows for your team
- Export importable blueprints and load them straight into your own n8n instance
- Keep a versioned snapshot of the catalog as templates get added or updated
- Seed a starter-kit gallery for onboarding new automation builders

**Competitive & Market Intelligence**
- See which apps dominate a category (AI, Sales, Marketing) by workflow volume
- Track emerging integrations by watching newly published templates
- Compare view counts to gauge which automations resonate with the community
- Identify gaps where few templates exist for a popular integration

**Training Data & AI**
- Build a dataset of real workflow graphs to fine-tune automation-generation models
- Extract node-and-connection structures for automation-recommendation engines
- Corpus of natural-language descriptions paired with runnable node graphs

**Agency & Consulting Delivery**
- Source ready-made workflows to deliver client automations faster
- Find creators to collaborate with using attached profile links and usernames
- Filter to a client's exact stack (e.g. Slack + Google Sheets) in one query

### Getting Started

#### Search by Keyword

The simplest way to start — one keyword, capped to a handful of results:

```json
{
    "searchQueries": ["chatgpt"],
    "maxResults": 25
}
````

#### Filter by Category and App

Narrow to AI-category workflows that use OpenAI, newest first:

```json
{
    "categories": ["AI"],
    "apps": ["OpenAI"],
    "sortBy": "createdAt",
    "maxResults": 100
}
```

#### Full Blueprint Enrichment

Pull the most-viewed Slack automations with the complete importable node graph on every row:

```json
{
    "searchQueries": ["slack notification"],
    "apps": ["Slack"],
    "sortBy": "views",
    "maxResults": 50,
    "includeWorkflowJson": true
}
```

#### Scrape Specific Templates by URL

Paste template links directly — these always carry the full blueprint:

```json
{
    "startUrls": [
        "https://n8n.io/workflows/1234-slack-daily-digest",
        "https://n8n.io/workflows/5678"
    ]
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["chatgpt"]` | Keywords to search the template library (e.g. "slack notification" or "invoice OCR"). Each query produces its own set of results. Leave empty to browse the whole library or to scrape only the template URLs. |
| `startUrls` | array | `[]` | Direct links to specific templates (e.g. "https://n8n.io/workflows/1234"). Use this to scrape exact templates you already have in mind. Works with or without search queries. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | array | `[]` | Only include templates in these categories: AI, Sales, IT Ops, Marketing, Document Ops, Support, Other. Leave empty for all categories. |
| `apps` | array | `[]` | Only include templates that use these integrations (e.g. "Slack", "OpenAI", "Google Sheets", "Gmail", "Notion"). Match the app name as it appears on n8n.io. Leave empty for any integration. |
| `sortBy` | string | `"views"` | How to order the templates: Most viewed or Newest first. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Maximum number of templates to return per search query. Set to 0 for all available templates. The library has over 10,000 templates, so keep this modest unless you want the full catalog. |

#### Enrichment

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeWorkflowJson` | boolean | `false` | Also fetch each template's complete workflow definition (the node graph and connections you can import into n8n) plus its preview image. Adds one extra fetch per template, so it increases runtime and cost — leave off if you only need the summary and author details. |

### Output

Here's a representative result with full blueprint enrichment enabled:

```json
{
    "id": 2462,
    "name": "Send a ChatGPT daily digest to Slack",
    "description": "Summarize your unread emails with OpenAI and post the digest to a Slack channel every morning.",
    "templateUrl": "https://n8n.io/workflows/2462",
    "totalViews": 48213,
    "createdAt": "2024-11-08T09:12:44.000Z",
    "price": 0,
    "purchaseUrl": null,
    "authorName": "Jane Doe",
    "authorUsername": "janedoe",
    "authorVerified": true,
    "authorBio": "Automation consultant. I build AI workflows for lean teams.",
    "authorAvatar": "https://gravatar.com/avatar/abc123.jpg",
    "authorLinks": ["https://janedoe.dev"],
    "categories": ["AI", "IT Ops"],
    "apps": ["Gmail", "OpenAI", "Slack"],
    "nodeCount": 6,
    "workflowJson": {
        "nodes": [
            { "name": "Schedule Trigger", "type": "n8n-nodes-base.scheduleTrigger", "position": [240, 300], "parameters": {} }
        ],
        "connections": {
            "Schedule Trigger": { "main": [[{ "node": "Gmail", "type": "main", "index": 0 }]] }
        }
    },
    "imageUrl": "https://n8niostorageaccount.blob.core.windows.net/preview/2462.png",
    "recordType": "template"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | number | Unique n8n template identifier |
| `name` | string | Template title |
| `description` | string | Template description |
| `templateUrl` | string | Canonical n8n.io template URL |
| `totalViews` | number | Total view count on n8n.io |
| `createdAt` | string | ISO timestamp the template was published |
| `recordType` | string | Always "template" |

#### Workflow Shape

| Field | Type | Description |
|-------|------|-------------|
| `apps` | string\[] | Integration/app display names the template uses (e.g. "Slack", "OpenAI") |
| `nodeCount` | number | Number of nodes (steps) in the workflow |
| `categories` | string\[] | Category names the template belongs to. Populated when `includeWorkflowJson` is on, and always present for `startUrls`; empty on summary-only rows |

#### Author

| Field | Type | Description |
|-------|------|-------------|
| `authorName` | string | Creator display name |
| `authorUsername` | string | Creator username on n8n.io |
| `authorVerified` | boolean | Whether the creator is a verified n8n creator |
| `authorBio` | string | Creator bio |
| `authorAvatar` | string | Creator avatar image URL |
| `authorLinks` | string\[] | Creator profile and website links |

#### Pricing & Blueprint

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price for paid templates (0 for free) |
| `purchaseUrl` | string | Purchase link for paid templates (null for free) |
| `workflowJson` | object | Full importable workflow: node graph, parameters, and connections. Populated when `includeWorkflowJson` is on, and always present for `startUrls` |
| `imageUrl` | string | Preview image URL. Populated with the blueprint fetch; null for templates that ship no preview |

### Tips for Best Results

- **Start small** — set `maxResults` to 25-50 on your first run to confirm the results match what you need, then scale up.
- **Match category and app names exactly** — spacing and casing matter: use "IT Ops" and "Document Ops" (not "ITOps"), and "Google Sheets" and "OpenAI" as they appear on n8n.io.
- **Combining categories narrows to their intersection** — listing "AI" and "Sales" returns only templates tagged with *both*, not either. Use one category at a time to widen.
- **Only enable `includeWorkflowJson` when you need the runnable graph** — it adds one fetch per template, so leave it off for a fast summary-only pass over thousands of results. This same fetch also fills each row's `categories` and preview `imageUrl`, so those are empty on a summary-only search run and populated once enrichment is on (or when you use `startUrls`).
- **Use `startUrls` for known templates** — pasted template links always return the full blueprint, even with the enrichment toggle off.
- **Sort by newest to monitor the catalog** — set `sortBy` to "Newest first" and re-run on a schedule to catch templates published since your last pass.
- **Leave every field empty to mirror the whole library** — no queries, no URLs, and no filters browses the full catalog (respecting `maxResults`).

### Pricing

**From $4.00 per 1,000 results** — 20% below the closest comparable n8n template scraper, and the only one that returns the full importable workflow blueprint. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.30 | $4.00 |
| 10,000 | $48.00 | $45.00 | $43.00 | $40.00 |
| 100,000 | $480.00 | $450.00 | $430.00 | $400.00 |

A "result" is any template row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available workflow templates from n8n.io for research, cataloging, and integration purposes. Users are responsible for complying with applicable laws and n8n's Terms of Service, and for respecting each template creator's licensing and attribution. Do not use extracted data for spam, harassment, or any illegal purpose. </content> </invoke>

# Actor input Schema

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

Keywords to search the n8n template library (e.g. 'slack notification' or 'invoice OCR'). Each query produces its own set of results. Leave empty to browse the whole library (optionally narrowed by the filters below), or to scrape only the Template URLs.

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

Direct links to specific templates (e.g. 'https://n8n.io/workflows/1234'). Use this to scrape exact templates you already have in mind. Works with or without search queries.

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

Only include templates in these categories. Leave empty for all categories.

## `apps` (type: `array`):

Only include templates that use these integrations (e.g. 'Slack', 'OpenAI', 'Google Sheets', 'Gmail', 'Telegram', 'Notion', 'Postgres', 'Discord', 'HTTP Request'). Each name must match n8n's exact integration name, including spacing and capitalization — a misspelled or partial name (e.g. 'google sheet' or 'slack ') returns no results rather than a close match. Leave empty for any integration.

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

How to order the templates.

## `maxResults` (type: `integer`):

Maximum number of templates to return per search query. Set to 0 for all available templates. The n8n library has over 10,000 templates, so keep this modest unless you want the full catalog.

## `includeWorkflowJson` (type: `boolean`):

Also fetch each template's complete workflow definition (the node graph and connections you can import into n8n), plus its preview image and category tags. This makes one extra request per template, so it increases runtime and cost — leave off if you only need the summary and author details. On a plain search run without this, the categories and preview image are left empty (they're always included for Template URLs).

## Actor input object example

```json
{
  "searchQueries": [
    "chatgpt"
  ],
  "startUrls": [],
  "categories": [],
  "apps": [],
  "sortBy": "views",
  "maxResults": 50,
  "includeWorkflowJson": false
}
```

# Actor output Schema

## `templates` (type: `string`):

Table of scraped n8n workflow templates with name, author, views, apps, and links.

# 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 = {
    "searchQueries": [
        "chatgpt"
    ],
    "startUrls": [],
    "categories": [],
    "apps": [],
    "sortBy": "views",
    "maxResults": 50,
    "includeWorkflowJson": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/n8n-workflow-templates-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 = {
    "searchQueries": ["chatgpt"],
    "startUrls": [],
    "categories": [],
    "apps": [],
    "sortBy": "views",
    "maxResults": 50,
    "includeWorkflowJson": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/n8n-workflow-templates-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 '{
  "searchQueries": [
    "chatgpt"
  ],
  "startUrls": [],
  "categories": [],
  "apps": [],
  "sortBy": "views",
  "maxResults": 50,
  "includeWorkflowJson": false
}' |
apify call solidcode/n8n-workflow-templates-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "n8n Workflow Templates Scraper",
        "description": "[💰 $4 / 1K] Extract n8n workflow automation templates — name, description, author, views, apps used, and the full importable workflow blueprint. Search by keyword and filter by category or integration.",
        "version": "1.0",
        "x-build-id": "4lQAiSLhcLWxBckGR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~n8n-workflow-templates-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-n8n-workflow-templates-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/solidcode~n8n-workflow-templates-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-n8n-workflow-templates-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/solidcode~n8n-workflow-templates-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-n8n-workflow-templates-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": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords to search the n8n template library (e.g. 'slack notification' or 'invoice OCR'). Each query produces its own set of results. Leave empty to browse the whole library (optionally narrowed by the filters below), or to scrape only the Template URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Template URLs",
                        "type": "array",
                        "description": "Direct links to specific templates (e.g. 'https://n8n.io/workflows/1234'). Use this to scrape exact templates you already have in mind. Works with or without search queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include templates in these categories. Leave empty for all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AI",
                                "Sales",
                                "IT Ops",
                                "Marketing",
                                "Document Ops",
                                "Support",
                                "Other"
                            ],
                            "enumTitles": [
                                "AI",
                                "Sales",
                                "IT Ops",
                                "Marketing",
                                "Document Ops",
                                "Support",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "apps": {
                        "title": "Apps / Integrations",
                        "type": "array",
                        "description": "Only include templates that use these integrations (e.g. 'Slack', 'OpenAI', 'Google Sheets', 'Gmail', 'Telegram', 'Notion', 'Postgres', 'Discord', 'HTTP Request'). Each name must match n8n's exact integration name, including spacing and capitalization — a misspelled or partial name (e.g. 'google sheet' or 'slack ') returns no results rather than a close match. Leave empty for any integration.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "views",
                            "createdAt"
                        ],
                        "type": "string",
                        "description": "How to order the templates.",
                        "default": "views"
                    },
                    "maxResults": {
                        "title": "Maximum Results per Query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of templates to return per search query. Set to 0 for all available templates. The n8n library has over 10,000 templates, so keep this modest unless you want the full catalog.",
                        "default": 50
                    },
                    "includeWorkflowJson": {
                        "title": "Include Full Workflow Blueprint",
                        "type": "boolean",
                        "description": "Also fetch each template's complete workflow definition (the node graph and connections you can import into n8n), plus its preview image and category tags. This makes one extra request per template, so it increases runtime and cost — leave off if you only need the summary and author details. On a plain search run without this, the categories and preview image are left empty (they're always included for Template URLs).",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
