# 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
- **Features:** Limited permissions
- **Stats:** 52 total users, 7 monthly users, 100.0% runs succeeded, 1 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

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

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/artbreeder-ai-image-generator/changelog.md

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/artbreeder-ai-image-generator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/objVduwcsGWoZXPCe/builds/Z6MrzhNPcDrXSCe4L/openapi.json