# Craiyon AI Image Creator (`maximedupre/craiyon-ai-image-creator`) Actor

Craiyon AI image creator for text prompts. Generate images with style, aspect ratio, and negative prompt controls, then export Apify download links, Craiyon source URLs, dimensions, categories, and timestamps.

- **URL**: https://apify.com/maximedupre/craiyon-ai-image-creator.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 generated images

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

### 🎨 Craiyon AI Image Creator for text prompts

Craiyon AI Image Creator generates images from text prompts on [Craiyon](https://www.craiyon.com/en). Add one or more prompts, choose a Craiyon style and aspect ratio, then export Apify download links, Craiyon source URLs, dimensions, categories, and generated timestamps from a clean Apify dataset.

Use this Actor when you want repeatable Craiyon text-to-image output for mood boards, concept art, icon ideas, product mockups, creative briefs, content drafts, or prompt experiments. Instead of opening Craiyon by hand for each idea, you can run a small batch in Apify Console, call the Actor through the Apify API, schedule runs, and export the results as JSON, CSV, Excel, XML, RSS, or HTML.

For a quick first run, keep the sample prompt, leave **Images per prompt** set to `1`, and keep the default automatic style and aspect ratio. Once the output shape looks right, add more prompts or adjust the style, aspect ratio, and optional negative prompt.

### ✅ What this Actor does

- Generates Craiyon images from one or more text prompts.
- Saves one dataset row per successfully generated image.
- Saves every accepted image and returns an Apify download URL.
- Returns the direct source image URL from Craiyon when available.
- Supports Craiyon style choices: automatic, artistic, photo, illustration, anime, vector, and raw.
- Supports automatic sizing, square, landscape, and portrait requests, and reports the actual generated shape in each output row.
- Lets you add a negative prompt when you want Craiyon to avoid specific visual elements.
- Includes dimensions, categories, resolved style, actual generated shape, and generated time.
- Skips failure and status placeholder rows so the dataset contains generated images only.

The Actor is built for Craiyon's public prompt generation flow. You do not need to provide a Craiyon account, cookies, or an API key.

### 📦 Data you can export

Each output item represents one successfully generated Craiyon image. Fields include:

- `prompt` and `promptIndex`
- `imageIndex`
- `sourceImageUrl`
- `width` and `height`
- `category`
- `style`
- `aspectRatio`
- `generatedAt`
- `downloadUrl`

The `sourceImageUrl` points to the generated image returned by Craiyon. The `downloadUrl` points to the copy saved by this Actor, which is usually the safer URL to use in downstream workflows.

Rows are saved as images finish, so a multi-prompt run can appear out of input order. Use `promptIndex` and `imageIndex` to match each image back to the requested prompt and image number.

### 🚀 How to run

1. Add one or more image prompts in **Prompts**.
2. Keep **Images per prompt** at `1` for the first run.
3. Leave **Style** and **Aspect ratio** on automatic unless you need a specific shape.
4. Optionally add a **Negative prompt** such as `text, watermark, blur`.
5. Start the Actor.
6. Open the dataset and use `downloadUrl` or `sourceImageUrl` for each generated image.

Clear visual prompts work best. Include the subject, medium, scene, lighting, color, composition, or style you care about.

```text
a simple teal glass button icon with soft studio lighting on a white background
a cozy reading nook with warm morning light, interior design render
a futuristic sneaker product photo on a reflective floor
````

### ⚙️ Input

```json
{
	"prompts": [
		"a simple teal glass button icon with soft studio lighting on a white background"
	],
	"imagesPerPrompt": 1,
	"negativePrompt": "",
	"style": "auto",
	"aspectRatio": "auto"
}
```

#### ✍️ Prompts

Enter text-to-image prompts. Empty and duplicate prompts are ignored. The Actor accepts up to 100 unique prompts in one run.

#### 🖼️ Generation settings

Use **Images per prompt** to request 1 to 4 saved images for each prompt. Use **Style** to choose Craiyon's generation style. Use **Aspect ratio** to keep Craiyon's automatic sizing or request square, landscape, or portrait output. Craiyon may still return a different final shape, which the Actor reports in `aspectRatio`.

Use **Negative prompt** when you want to avoid specific elements such as text, watermark, blur, extra limbs, or a color you do not want in the scene.

### 📄 Output example

```json
{
	"prompt": "a simple teal glass button icon with soft studio lighting on a white background",
	"promptIndex": 0,
	"imageIndex": 0,
	"downloadUrl": "https://api.apify.com/v2/key-value-stores/example-store/records/craiyon-001-001-exampleImageId.webp",
	"sourceImageUrl": "https://img.craiyon.com/2026-06-01/example.webp",
	"width": 1024,
	"height": 1024,
	"category": ["icon", "graphic design", "minimalist"],
	"style": "vector",
	"aspectRatio": "square",
	"generatedAt": "2026-06-01T11:52:54.185Z"
}
```

### 💸 Pricing

This Actor uses pay-per-event pricing. You are charged for each generated image that is successfully saved for download and export. Invalid input, skipped generations, failed downloads, and runs that do not save generated images do not create generated-image events.

There is no separate Actor-start charge in this pricing setup.

### ⚠️ Limits and caveats

Craiyon can sometimes reject a prompt, return no image, temporarily block anonymous generation, or be unavailable. When that happens, the Actor logs a warning, skips the failed image, and keeps any generated images already saved in the dataset.

The dataset contains only generated image rows. It does not include failed prompt rows, screenshots, source page HTML, prompt quality scores, or image editing results.

Generated media availability can depend on both Craiyon and Apify storage. Use `downloadUrl` when you want the copy saved by the Actor.

### ❓ FAQ

#### 🔐 Do I need a Craiyon account?

No. The Actor runs against Craiyon's public prompt generation flow and does not ask you for Craiyon cookies, login details, or an API key.

#### ⚠️ Why did a prompt return no image?

Craiyon may reject some prompts, temporarily block anonymous generation, run out of capacity, or fail to return a downloadable image. The Actor handles that as a skipped generation and continues with the rest of the run when possible.

#### 🔗 Which URL should I use in my workflow?

Use `downloadUrl` when you want the image copy saved by the Actor. Use `sourceImageUrl` when you specifically need the original Craiyon-hosted image URL returned by the source.

#### 🖼️ Can I generate several images for the same prompt?

Yes. Set **Images per prompt** from `1` to `4`. Each successfully saved image creates one dataset row and one generated-image pricing event.

### 📝 Changelog

- 1.0: Simplified output rows to focus on image download, source URL, prompt mapping, resolved style and shape, dimensions, categories, and generated time.
- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~craiyon-ai-image-creator/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Artbreeder AI Image Creator ↗](https://apify.com/maximedupre/artbreeder-ai-image-creator) - Generate Artbreeder images from prompts with model and shape controls.
- [Unsplash Image Scraper ↗](https://apify.com/maximedupre/unsplash-image-scraper) - Collect Unsplash image search results for design and content research.
- [Font Detector ↗](https://apify.com/maximedupre/font-detector) - Detect fonts, font files, and CSS font families from public web pages.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - Export Pinterest autocomplete keyword ideas for creative and SEO planning.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Build rendered website link maps for audits and content workflows.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter one or more Craiyon text prompts. Clear visual prompts work best, such as product photos, concept art, simple icons, mood boards, or character ideas.

## `imagesPerPrompt` (type: `integer`):

How many generated images to save for each prompt. Keep this at 1 for a small first run.

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

Optional words or concepts you want Craiyon to avoid, such as text, watermark, blur, extra limbs, or a color you do not want.

## `style` (type: `string`):

Choose one of Craiyon's public style presets, or let Craiyon decide automatically.

## `aspectRatio` (type: `string`):

Choose Craiyon's automatic sizing or request square, landscape, or portrait output. Output rows report the actual generated shape in aspectRatio.

## Actor input object example

```json
{
  "prompts": [
    "a simple teal glass button icon with soft studio lighting on a white background"
  ],
  "imagesPerPrompt": 1,
  "negativePrompt": "",
  "style": "auto",
  "aspectRatio": "auto"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with Apify download links, Craiyon source image URLs, dimensions, categories, resolved style and shape, and generated timestamps.

# 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 simple teal glass button icon with soft studio lighting on a white background"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/craiyon-ai-image-creator").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 simple teal glass button icon with soft studio lighting on a white background"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/craiyon-ai-image-creator").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 simple teal glass button icon with soft studio lighting on a white background"
  ]
}' |
apify call maximedupre/craiyon-ai-image-creator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craiyon AI Image Creator",
        "description": "Craiyon AI image creator for text prompts. Generate images with style, aspect ratio, and negative prompt controls, then export Apify download links, Craiyon source URLs, dimensions, categories, and timestamps.",
        "version": "1.0",
        "x-build-id": "o2w0FEtorYbVxzk9Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~craiyon-ai-image-creator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-craiyon-ai-image-creator",
                "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/maximedupre~craiyon-ai-image-creator/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-craiyon-ai-image-creator",
                "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/maximedupre~craiyon-ai-image-creator/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-craiyon-ai-image-creator",
                "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": "Enter one or more Craiyon text prompts. Clear visual prompts work best, such as product photos, concept art, simple icons, mood boards, or character ideas.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "imagesPerPrompt": {
                        "title": "Images per prompt",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "How many generated images to save for each prompt. Keep this at 1 for a small first run.",
                        "default": 1
                    },
                    "negativePrompt": {
                        "title": "Negative prompt",
                        "type": "string",
                        "description": "Optional words or concepts you want Craiyon to avoid, such as text, watermark, blur, extra limbs, or a color you do not want.",
                        "default": ""
                    },
                    "style": {
                        "title": "Style",
                        "enum": [
                            "auto",
                            "art",
                            "photo",
                            "illustration",
                            "anime",
                            "vector",
                            "raw"
                        ],
                        "type": "string",
                        "description": "Choose one of Craiyon's public style presets, or let Craiyon decide automatically.",
                        "default": "auto"
                    },
                    "aspectRatio": {
                        "title": "Aspect ratio",
                        "enum": [
                            "auto",
                            "square",
                            "landscape",
                            "portrait"
                        ],
                        "type": "string",
                        "description": "Choose Craiyon's automatic sizing or request square, landscape, or portrait output. Output rows report the actual generated shape in aspectRatio.",
                        "default": "auto"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```