# Artbreeder AI Image Generator (`parsebird/artbreeder-ai-image-generator`) Actor

Generate AI images from text prompts using Artbreeder. Choose from 7 models (Flux, Flux Krea, SDXL Lightning, SD-3.5). Customize dimensions, guidance scale, inference steps. Batch processing with NSFW detection. Export as JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/artbreeder-ai-image-generator.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 image generateds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Artbreeder AI Image Generator

Generate AI images from text prompts using [Artbreeder](https://www.artbreeder.com)'s text-to-image models. Choose from 7 AI models including Flux, Flux Krea, SDXL Lightning, and Stable Diffusion 3.5 — customize dimensions, guidance scale, and inference steps for full creative control. Export as JSON, CSV, or Excel.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Generate images from text prompts using 7 Artbreeder AI models (Flux, Flux Krea, SDXL Lightning, SD-3.5) with 5 aspect ratios, negative prompts, adjustable guidance scale and inference steps, automatic NSFW detection, and batch processing — ready for download or API integration.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

Apify Actor: parsebird/artbreeder-ai-image-generator — generates AI images from text prompts using Artbreeder. $0.005/image ($5/1000). Call via ApifyClient: client.actor("parsebird/artbreeder-ai-image-generator").call(run\_input={"prompts": \["A cosmic tree with stars and galaxies"], "modelVersion": "flux-krea", "shape": "square", "guidanceScale": 5, "numInferenceSteps": 8}). Inputs: prompts (array of strings, required), negativePrompt (string, optional), modelVersion (string, flux-dev/flux-schnell/flux-krea/sdxl-1.0-lightning/sd-3.5-large/sd-3.5-medium/sdxl-1.0, default flux-krea), guidanceScale (integer 1–20, default 5), shape (square/wider/wide/tall/taller, default square), numInferenceSteps (integer 1–50, default 25), proxyConfiguration (object, optional). Output: dataset with prompt, image\_url, image\_size, is\_nsfw. API docs: https://docs.apify.com/api/v2 Token: https://console.apify.com/settings/integrations

````

### What does Artbreeder AI Image Generator do?

**Artbreeder AI Image Generator** is an [Apify Actor](https://docs.apify.com/platform/actors) that generates AI-powered images from text prompts using [Artbreeder](https://www.artbreeder.com)'s text-to-image models. It provides a programmatic alternative to Artbreeder's web-based [Prompter tool](https://www.artbreeder.com/tools/prompter), allowing you to generate images at scale via API, schedule recurring runs, and integrate image generation into automated workflows.

Key features:

- 🎨 **7 AI models** — Flux (high quality), Flux Schnell (fast), Flux Krea (balanced), SDXL Lightning (fastest), SD 3.5 Large, SD 3.5 Medium, SDXL 1.0
- 📐 **5 image shapes** — Square (1024x1024), Wider (1256x840), Wide (1184x888), Tall (888x1184), Taller (840x1256)
- 🚫 **Negative prompts** — exclude unwanted elements like blur, text, or watermarks from generated images
- 🎛️ **Fine-tuned control** — adjust guidance scale (prompt adherence) and inference steps (quality vs. speed)
- 📦 **Batch processing** — generate multiple images from a list of prompts in a single run
- 🔍 **NSFW detection** — automatic content safety flagging for each generated image
- ⚡ **Fast API-based generation** — no browser needed, lightweight and cost-efficient
- 📅 **Schedule and automate** — run on a schedule via [Apify Schedules](https://docs.apify.com/platform/schedules) for recurring image generation
- 🔌 **Integrations** — connect to Google Sheets, Slack, Zapier, Make, and [more](https://docs.apify.com/platform/integrations)
- 📤 **Multiple export formats** — download results as JSON, CSV, Excel, XML, or HTML table

Artbreeder AI Image Generator uses Artbreeder's internal API — the same engine powering their Prompter tool — to generate images from your text descriptions. No Artbreeder account is required.

### What data can you extract from Artbreeder?

| Field | Description |
|-------|-------------|
| `prompt` | The original text description used for image generation |
| `image_url` | Direct URL to download the AI-generated image |
| `image_size` | Image dimensions as [width, height] (e.g. [1024, 1024]) |
| `is_nsfw` | Content safety indicator — `true` if potentially inappropriate content detected |

### How to generate images with Artbreeder AI Image Generator

1. **Go to Artbreeder AI Image Generator** on [Apify Store](https://apify.com/parsebird/artbreeder-ai-image-generator) and click **Try for free**
2. **Enter your prompts** — add one or more text descriptions of the images you want to generate
3. **Choose an AI model** — select from 7 models: Flux Krea (recommended), Flux Schnell (fast), SDXL Lightning (fastest), and more
4. **Set image shape** — pick an aspect ratio: Square, Wide, Wider, Tall, or Taller
5. **Adjust quality settings (optional)** — set guidance scale and inference steps for fine-tuned results
6. **Add a negative prompt (optional)** — describe what to exclude (e.g. "blurry, low quality, text, watermark")
7. **Run the generator** — click **Start** and wait for your images
8. **Export your images** — download results as JSON, CSV, or Excel, or access via API

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `prompts` | array | **Yes** | — | List of text prompts for generating images |
| `negativePrompt` | string | No | `""` | Elements to exclude from generated images |
| `modelVersion` | string | No | `flux-krea` | AI model: `flux-dev`, `flux-schnell`, `flux-krea`, `sdxl-1.0-lightning`, `sd-3.5-large`, `sd-3.5-medium`, `sdxl-1.0` |
| `guidanceScale` | integer | No | 5 | Prompt adherence (1–20). Higher = more literal |
| `shape` | string | No | `square` | Image aspect ratio: `square`, `wider`, `wide`, `tall`, `taller` |
| `numInferenceSteps` | integer | No | 25 | Quality steps (1–50). Higher = better quality, slower |
| `proxyConfiguration` | object | No | Apify Proxy | Proxy settings (residential recommended) |

**Notes:**
- For the **SDXL Lightning** model, inference steps are capped at **8**.
- For the **Flux Schnell** model, inference steps are capped at **12**.
- For **SDXL models** (SDXL Lightning, SDXL 1.0), the guidance scale is capped at **12**.

### Output example

```json
[
    {
        "prompt": "A beautiful sunset over the mountains",
        "image_url": "https://artbreederpublic-shortlived.s3.amazonaws.com/30d/imgs/4584b05006844909b61c364a.jpeg",
        "image_size": [1024, 1024],
        "is_nsfw": false
    },
    {
        "prompt": "A futuristic cityscape",
        "image_url": "https://artbreederpublic-shortlived.s3.amazonaws.com/30d/imgs/615e0dde14cc44449f517218.jpeg",
        "image_size": [1024, 1024],
        "is_nsfw": false
    },
    {
        "prompt": "A cosmic tree with stars and galaxies hanging from its branches",
        "image_url": "https://artbreederpublic-shortlived.s3.amazonaws.com/30d/imgs/082a2505084f41febd71a6e6.jpeg",
        "image_size": [1024, 1024],
        "is_nsfw": false
    }
]
````

Download results in JSON, CSV, Excel, or access via the [Apify API](https://docs.apify.com/api/v2).

### Use cases

- **Content creation** — generate unique images for blog posts, articles, social media, and newsletters at scale
- **Marketing and advertising** — create custom visuals for campaigns, ads, and promotional materials without stock photos
- **Game design and concept art** — produce concept art, character designs, and environment sketches from text descriptions
- **Social media automation** — schedule recurring runs to generate fresh images for social media accounts on a regular cadence
- **E-commerce product visualization** — create product mockups and lifestyle imagery for online stores
- **Education and training materials** — generate illustrative images for presentations, courses, and learning content
- **Creative exploration** — experiment with different AI models, styles, and prompt techniques for artistic projects

### How it works

1. **Input parsing** — the actor reads your prompts, model selection, shape, and quality settings
2. **Model cap enforcement** — inference steps and guidance scale are automatically capped based on the selected model (SDXL Lightning max 8 steps, Flux Schnell max 12 steps, SDXL models max 12 guidance)
3. **Image generation** — each prompt is sent to Artbreeder's text-to-image API with your configuration
4. **Response processing** — the generated image URL, dimensions, and NSFW flag are extracted from the API response
5. **Dataset push** — each result is pushed to the Apify dataset immediately after generation
6. **Pay-per-event charging** — one event is charged per generated image, with automatic budget limit detection

### How to use via API — Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("parsebird/artbreeder-ai-image-generator").call(run_input={
    "prompts": [
        "A majestic lion with a crown of stars, in a cosmic nebula",
        "An enchanted forest library with glowing books floating in the air"
    ],
    "negativePrompt": "low detail, blurry, text, watermark",
    "modelVersion": "flux-krea",
    "shape": "square",
    "guidanceScale": 5,
    "numInferenceSteps": 8,
})

for image in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Prompt: {image['prompt']}")
    print(f"Image URL: {image['image_url']}")
    print(f"NSFW: {image['is_nsfw']}")
    print()
```

### How to use via API — JavaScript

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

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

const run = await client.actor('parsebird/artbreeder-ai-image-generator').call({
    prompts: [
        'A majestic lion with a crown of stars, in a cosmic nebula',
        'An enchanted forest library with glowing books floating in the air',
    ],
    negativePrompt: 'low detail, blurry, text, watermark',
    modelVersion: 'flux-krea',
    shape: 'square',
    guidanceScale: 5,
    numInferenceSteps: 8,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(image => {
    console.log(`Prompt: ${image.prompt}`);
    console.log(`Image URL: ${image.image_url}`);
    console.log(`NSFW: ${image.is_nsfw}`);
    console.log();
});
```

### How much does it cost to generate Artbreeder images?

Artbreeder AI Image Generator uses [pay-per-event pricing](https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event) — you pay per generated image, not for platform compute time.

**How much does it cost to generate 1,000 Artbreeder images?**

$5.00. Each image costs $0.005. New users get a free trial with $5 of platform credit.

**How much does it cost to generate 100 Artbreeder images?**

$0.50. A quick batch of images for a single project.

### Pricing

| Event | Price per event | Price per 1,000 |
|-------|----------------|-----------------|
| `image-generated` | $0.005 | **$5.00** |

Each image pushed to the dataset counts as one event. Apify platform usage (compute, proxy) is included in the event price.

Typical costs:

- 3 images (quick test): ~$0.015
- 10 images (small batch): ~$0.05
- 100 images (project batch): ~$0.50
- 1,000 images (large batch): ~$5.00

### Is it legal to use Artbreeder's API?

This Actor accesses [Artbreeder](https://www.artbreeder.com)'s publicly available text-to-image generation service — the same functionality any browser user can access through the [Prompter tool](https://www.artbreeder.com/tools/prompter). No login or authentication is required. Generated images are subject to Artbreeder's [Terms of Service](https://www.artbreeder.com/terms) and content policies.

Web scraping of publicly available data is generally legal in the United States and the European Union, as established by the [hiQ Labs v. LinkedIn ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn). For more information, see Apify's guide on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

Users are responsible for ensuring their use of generated images complies with applicable laws, Artbreeder's Terms of Service, and any relevant copyright or licensing requirements in their jurisdiction.

### Other AI image generation tools on Apify

Looking for more AI image generation and creative tools? Check out these actors:

- [Polymarket Leaderboard Scraper](https://apify.com/parsebird/polymarket-scraper) — Scrape top traders from Polymarket prediction markets
- [Polymarket Market Scraper](https://apify.com/parsebird/polymarket-market-scraper) — Extract market data, odds, and liquidity from Polymarket
- [Substack Leaderboard Scraper](https://apify.com/parsebird/substack-leaderboard-scraper) — Scrape top Substack newsletters by category
- [GMGN CopyTrade Wallet Scraper](https://apify.com/parsebird/gmgn-copytrade-wallet-scraper) — Scrape crypto wallet leaderboards from GMGN.ai

Browse all [ParseBird actors on Apify Store](https://apify.com/parsebird).

### FAQ

**What AI models are available?**
Artbreeder AI Image Generator supports 7 models: Flux (high quality), Flux Schnell (fast, max 12 inference steps), Flux Krea (balanced quality and speed), SDXL Lightning (fastest, max 8 inference steps), SD 3.5 Large, SD 3.5 Medium, and SDXL 1.0. We recommend Flux Krea for the best balance of quality and generation speed.

**What image sizes are supported?**
Five aspect ratios: Square (1024x1024), Wider (1256x840), Wide (1184x888), Tall (888x1184), and Taller (840x1256). Choose the shape that best fits your project needs.

**What does the guidance scale do?**
Guidance scale controls how closely the AI model follows your text prompt. Higher values (closer to 20) produce images that match your prompt more literally, while lower values (closer to 1) give the model more creative freedom. The default is 5. For SDXL models, guidance scale is capped at 12.

**What are inference steps?**
Inference steps control image quality. More steps generally produce more detailed, refined images but take longer to generate. The default is 25. Model-specific limits: SDXL Lightning caps at 8 steps, Flux Schnell caps at 12 steps.

**Can I schedule recurring image generation runs?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to generate images on a daily, weekly, or custom interval. Combine with dynamic prompt lists to automate content creation workflows.

**Can I access the results via API?**
Yes. Use the [Apify API](https://docs.apify.com/api/v2) or the official [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js) client libraries to run the actor and retrieve generated images programmatically. See the API usage examples above.

**What export formats are supported?**
JSON, CSV, Excel (XLSX), XML, HTML, and RSS. Download directly from the Apify Console or via the API.

**Does it detect NSFW content?**
Yes. Each generated image includes an `is_nsfw` field indicating whether potentially inappropriate content was detected. This flag is provided by Artbreeder's API.

**Does it require an Artbreeder account?**
No. This actor accesses Artbreeder's public text-to-image generation service. No Artbreeder login, account, or API key is needed.

**Is there a free trial?**
Yes. New Apify users get $5 of free platform credit, which covers approximately 1,000 generated images.

**I found an issue or have a feature request.**
Open an issue on the [Issues tab](https://apify.com/parsebird/artbreeder-ai-image-generator/issues) or contact ParseBird via the Apify Console.

# Actor input Schema

## `prompts` (type: `array`):

List of text prompts for generating images. Each prompt produces one image.

## `negativePrompt` (type: `string`):

Elements to exclude from generated images (e.g. 'blurry, low quality, text, watermark'). Applies to all prompts.

## `modelVersion` (type: `string`):

Artbreeder AI model to use for image generation. Flux Krea offers the best balance of quality and speed.

## `guidanceScale` (type: `integer`):

Controls how closely the model follows your prompt. Higher values = more literal, lower values = more creative. For SDXL models, values are capped at 12.

## `shape` (type: `string`):

Aspect ratio and dimensions of the generated image.

## `numInferenceSteps` (type: `integer`):

Number of compute steps for image generation. Higher values = better quality but slower. Model limits: SDXL Lightning max 8, Flux Schnell max 12.

## `proxyConfiguration` (type: `object`):

Proxy settings. Residential proxies are recommended for reliable image generation from Artbreeder.

## Actor input object example

```json
{
  "prompts": [
    "A cosmic tree with stars and galaxies hanging from its branches",
    "A glass bridge spanning across two floating mountains",
    "Mermaids singing in an underwater concert"
  ],
  "negativePrompt": "",
  "modelVersion": "flux-krea",
  "guidanceScale": 5,
  "shape": "square",
  "numInferenceSteps": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "prompts": [
        "A cosmic tree with stars and galaxies hanging from its branches",
        "A glass bridge spanning across two floating mountains",
        "Mermaids singing in an underwater concert"
    ],
    "modelVersion": "flux-krea",
    "guidanceScale": 5,
    "shape": "square",
    "numInferenceSteps": 8,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/artbreeder-ai-image-generator").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 = {
    "prompts": [
        "A cosmic tree with stars and galaxies hanging from its branches",
        "A glass bridge spanning across two floating mountains",
        "Mermaids singing in an underwater concert",
    ],
    "modelVersion": "flux-krea",
    "guidanceScale": 5,
    "shape": "square",
    "numInferenceSteps": 8,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/artbreeder-ai-image-generator").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 '{
  "prompts": [
    "A cosmic tree with stars and galaxies hanging from its branches",
    "A glass bridge spanning across two floating mountains",
    "Mermaids singing in an underwater concert"
  ],
  "modelVersion": "flux-krea",
  "guidanceScale": 5,
  "shape": "square",
  "numInferenceSteps": 8,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parsebird/artbreeder-ai-image-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parsebird/artbreeder-ai-image-generator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Artbreeder AI Image Generator",
        "description": "Generate AI images from text prompts using Artbreeder. Choose from 7 models (Flux, Flux Krea, SDXL Lightning, SD-3.5). Customize dimensions, guidance scale, inference steps. Batch processing with NSFW detection. Export as JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "icXLBzk59MHXUl380"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~artbreeder-ai-image-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-artbreeder-ai-image-generator",
                "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/parsebird~artbreeder-ai-image-generator/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-artbreeder-ai-image-generator",
                "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/parsebird~artbreeder-ai-image-generator/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-artbreeder-ai-image-generator",
                "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": [
                    "prompts"
                ],
                "properties": {
                    "prompts": {
                        "title": "Prompts",
                        "type": "array",
                        "description": "List of text prompts for generating images. Each prompt produces one image.",
                        "default": [
                            "A cosmic tree with stars and galaxies hanging from its branches",
                            "A glass bridge spanning across two floating mountains",
                            "Mermaids singing in an underwater concert"
                        ]
                    },
                    "negativePrompt": {
                        "title": "Negative Prompt",
                        "type": "string",
                        "description": "Elements to exclude from generated images (e.g. 'blurry, low quality, text, watermark'). Applies to all prompts.",
                        "default": ""
                    },
                    "modelVersion": {
                        "title": "Model Version",
                        "enum": [
                            "flux-dev",
                            "flux-schnell",
                            "flux-krea",
                            "sdxl-1.0-lightning",
                            "sd-3.5-large",
                            "sd-3.5-medium",
                            "sdxl-1.0"
                        ],
                        "type": "string",
                        "description": "Artbreeder AI model to use for image generation. Flux Krea offers the best balance of quality and speed.",
                        "default": "flux-krea"
                    },
                    "guidanceScale": {
                        "title": "Guidance Scale",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Controls how closely the model follows your prompt. Higher values = more literal, lower values = more creative. For SDXL models, values are capped at 12.",
                        "default": 5
                    },
                    "shape": {
                        "title": "Image Shape",
                        "enum": [
                            "square",
                            "wider",
                            "wide",
                            "tall",
                            "taller"
                        ],
                        "type": "string",
                        "description": "Aspect ratio and dimensions of the generated image.",
                        "default": "square"
                    },
                    "numInferenceSteps": {
                        "title": "Inference Steps",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of compute steps for image generation. Higher values = better quality but slower. Model limits: SDXL Lightning max 8, Flux Schnell max 12.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for reliable image generation from Artbreeder."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```