A fast, low-latency version of ERNIE Image by Baidu, optimized for rapid iteration and scalable image generation.Balances speed and quality, ideal for real-time and high-throughput scenarios.
Join the Discord community for the latest model updates, prompts, and support.
Your request will cost $0.56 per run. For $10 you can run this model approximately 17 times.
Here's what you can do next:
import requests
import time
# Step 1: Start image generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
"model": "baidu/ERNIE-Image-Turbo/text-to-image", # Required. Model name
"prompt": "A beautiful landscape with mountains and lake", # Required. The positive prompt for the generation
"size": "1024x1024", # The size of the generated media in pixels (widthxheight)
"n": 1, # Number of images to generate. (min: 1, max: 10)
"seed": -1, # Random seed for generation
"use_pe": True, # Use PE for generation
"num_inference_steps": 8, # Number of inference steps. (min: 1, max: 100)
"guidance_scale": 1, # Guidance scale for generation. (min: 1, max: 20)
"enable_sync_mode": False, # If set to true, the function waits for final output before returning
"enable_base64_output": False, # If enabled, output can be encoded as BASE64 instead of URL
}
generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]
# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
def check_status():
while True:
response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
result = response.json()
if result["data"]["status"] == "completed":
print("Generated image:", result["data"]["outputs"][0])
return result["data"]["outputs"][0]
elif result["data"]["status"] == "failed":
raise Exception(result["data"]["error"] or "Generation failed")
else:
# Still processing, wait 2 seconds
time.sleep(2)
image_url = check_status()Install the required package for your language.
pip install requestsAll API requests require authentication via an API key. You can get your API key from the Atlas Cloud dashboard.
export ATLASCLOUD_API_KEY="your-api-key-here"import os
API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {API_KEY}"
}Never expose your API key in client-side code or public repositories. Use environment variables or a backend proxy instead.
import requests
url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
"model": "your-model",
"prompt": "A beautiful landscape"
}
response = requests.post(url, headers=headers, json=data)
print(response.json())Submit an asynchronous generation request. The API returns a prediction ID that you can use to check the status and retrieve the result.
/api/v1/model/generateImageimport requests
url = "https://api.atlascloud.ai/api/v1/model/generateImage"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
"model": "baidu/ERNIE-Image-Turbo/text-to-image",
"prompt": "A beautiful landscape with mountains and lake"
}
response = requests.post(url, headers=headers, json=data)
result = response.json()
print(f"Prediction ID: {result['data']['id']}")
print(f"Status: {result['data']['status']}"){
"code": 200,
"data": {
"id": "pred_abc123",
"status": "processing",
"model": "model-name",
"created_at": "2025-01-01T00:00:00Z"
}
}Poll the prediction endpoint to check the current status of your request.
/api/v1/model/prediction/{prediction_id}import requests
import time
prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }
while True:
response = requests.get(url, headers=headers)
result = response.json()
status = result["data"]["status"]
print(f"Status: {status}")
if status in ["completed", "succeeded"]:
output_url = result["data"]["outputs"][0]
print(f"Output URL: {output_url}")
break
elif status == "failed":
print(f"Error: {result['data'].get('error', 'Unknown')}")
break
time.sleep(3)processingThe request is still being processed.completedGeneration is complete. Outputs are available.succeededGeneration succeeded. Outputs are available.failedGeneration failed. Check the error field.{
"data": {
"id": "pred_abc123",
"status": "completed",
"outputs": [
"https://storage.atlascloud.ai/outputs/result.png"
],
"metrics": {
"predict_time": 8.3
},
"created_at": "2025-01-01T00:00:00Z",
"completed_at": "2025-01-01T00:00:10Z"
}
}Upload files to Atlas Cloud storage and get a URL you can use in your API requests. Use multipart/form-data to upload.
/api/v1/model/uploadMediaimport requests
url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }
with open("image.png", "rb") as f:
files = {"file": ("image.png", f, "image/png")}
response = requests.post(url, headers=headers, files=files)
result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}"){
"data": {
"download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
"file_name": "image.png",
"content_type": "image/png",
"size": 1024000
}
}The following parameters are accepted in the request body.
{
"model": "baidu/ERNIE-Image-Turbo/text-to-image",
"prompt": "A beautiful landscape",
"size": "1024x1024",
"n": 1,
"seed": -1,
"use_pe": true,
"num_inference_steps": 8,
"guidance_scale": 1,
"enable_sync_mode": false,
"enable_base64_output": false
}The API returns a prediction response with the generated output URLs.
{
"id": "pred_abc123",
"status": "completed",
"model": "model-name",
"outputs": [
"https://storage.atlascloud.ai/outputs/result.png"
],
"metrics": {
"predict_time": 8.3
},
"created_at": "2025-01-01T00:00:00Z",
"completed_at": "2025-01-01T00:00:10Z"
}Atlas Cloud Skills integrates 400+ AI models directly into your AI coding assistant. One command to install, then use natural language to generate images, videos, and chat with LLMs.
npx skills add AtlasCloudAI/atlas-cloud-skillsGet your API key from the Atlas Cloud dashboard and set it as an environment variable.
export ATLASCLOUD_API_KEY="your-api-key-here"Once installed, you can use natural language in your AI assistant to access all Atlas Cloud models.
Atlas Cloud MCP Server connects your IDE with 400+ AI models via the Model Context Protocol. Works with any MCP-compatible client.
npx -y atlascloud-mcpAdd the following configuration to your IDE's MCP settings file.
{
"mcpServers": {
"atlascloud": {
"command": "npx",
"args": [
"-y",
"atlascloud-mcp"
],
"env": {
"ATLASCLOUD_API_KEY": "your-api-key-here"
}
}
}
}{
"info": {
"description": "The AtlasCloud API.",
"title": "AtlasCloud API",
"version": "1.0.0"
},
"paths": {
"/api/v1/model/generateImage": {
"post": {
"responses": {
"200": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PredictionResponse"
}
}
},
"description": "The request status."
}
},
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Input"
}
}
}
}
},
"x-api-name": "model_run"
},
"/api/v1/model/result/{request_id}": {
"get": {
"responses": {
"200": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PredictionResponse"
}
}
},
"description": "Result of the request."
}
},
"parameters": [
{
"in": "path",
"name": "request_id",
"schema": {
"type": "string",
"description": "Request ID"
},
"required": true
}
]
},
"x-api-name": "model_result"
}
},
"openapi": "3.0.0",
"servers": [
{
"url": "https://api.atlascloud.ai"
}
],
"components": {
"schemas": {
"Input": {
"type": "object",
"required": [
"model",
"prompt"
],
"properties": {
"model": {
"type": "string",
"description": "Model name",
"default": "baidu/ERNIE-Image-Turbo/text-to-image"
},
"prompt": {
"type": "string",
"minLength": 1,
"description": "The positive prompt for the generation."
},
"size": {
"type": "string",
"default": "1024x1024",
"description": "The size of the generated media in pixels (widthxheight).",
"enum": [
"1024x1024",
"1376x768",
"1264x848",
"1200x896",
"896x1200",
"848x1264",
"768x1376"
],
"x-ui-component": "select width*height"
},
"n": {
"type": "integer",
"default": 1,
"minimum": 1,
"maximum": 10,
"description": "Number of images to generate."
},
"seed": {
"type": "integer",
"default": -1,
"description": "Random seed for generation. Use -1 for random. "
},
"use_pe": {
"type": "boolean",
"default": true,
"description": "Use PE for generation."
},
"num_inference_steps": {
"type": "integer",
"default": 8,
"minimum": 1,
"maximum": 100,
"description": "Number of inference steps."
},
"guidance_scale": {
"type": "number",
"default": 1,
"minimum": 1,
"maximum": 20,
"description": "Guidance scale for generation."
},
"enable_sync_mode": {
"type": "boolean",
"default": false,
"disabled": true,
"description": "If set to true, the function waits for final output before returning."
},
"enable_base64_output": {
"type": "boolean",
"default": false,
"disabled": true,
"description": "If enabled, output can be encoded as BASE64 instead of URL."
}
},
"x-order-properties": [
"model",
"prompt",
"size",
"n",
"seed",
"use_pe",
"num_inference_steps",
"guidance_scale",
"enable_sync_mode",
"enable_base64_output"
]
},
"PredictionResponse": {
"type": "object",
"properties": {
"created_at": {
"type": "string",
"format": "date-time",
"description": "ISO timestamp of when the request was created."
},
"has_nsfw_contents": {
"type": "array",
"description": "Array of boolean values indicating NSFW detection for each output.",
"items": {
"type": "boolean"
}
},
"id": {
"type": "string",
"description": "Unique identifier for the prediction."
},
"model": {
"type": "string",
"description": "Model ID used for the prediction."
},
"outputs": {
"type": "array",
"description": "Array of URLs to the generated content (empty when status is not completed).",
"items": {
"type": "string"
}
},
"status": {
"type": "string",
"description": "Status of the task: created, processing, completed, or failed."
},
"urls": {
"type": "object",
"description": "Object containing related API endpoints."
}
}
}
},
"securitySchemes": {
"apiKeyAuth": {
"in": "header",
"name": "Authorization",
"type": "apiKey"
}
}
}
}# baidu/ERNIE-Image-Turbo/text-to-image
> A fast, low-latency version of ERNIE Image by Baidu, optimized for rapid iteration and scalable image generation.Balances speed and quality, ideal for real-time and high-throughput scenarios.
## Overview
- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateImage` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `baidu/ERNIE-Image-Turbo/text-to-image`
## API Information
This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.
### Input Schema
The API accepts the following input parameters:
- **`model`** (`string`, _required_):
Model name
- Default: `"baidu/ERNIE-Image-Turbo/text-to-image"`
- **`prompt`** (`string`, _required_):
The positive prompt for the generation.
- **`size`** (`string`, _optional_):
The size of the generated media in pixels (widthxheight).
- Default: `"1024x1024"`
- Options: "1024x1024", "1376x768", "1264x848", "1200x896", "896x1200", "848x1264", "768x1376"
- **`n`** (`integer`, _optional_):
Number of images to generate.
- Default: `1`
- Min: 1
- Max: 10
- **`seed`** (`integer`, _optional_):
Random seed for generation. Use -1 for random.
- Default: `-1`
- **`use_pe`** (`boolean`, _optional_):
Use PE for generation.
- Default: `true`
- **`num_inference_steps`** (`integer`, _optional_):
Number of inference steps.
- Default: `8`
- Min: 1
- Max: 100
- **`guidance_scale`** (`number`, _optional_):
Guidance scale for generation.
- Default: `1`
- Min: 1
- Max: 20
- **`enable_sync_mode`** (`boolean`, _optional_):
If set to true, the function waits for final output before returning.
- Default: `false`
- **`enable_base64_output`** (`boolean`, _optional_):
If enabled, output can be encoded as BASE64 instead of URL.
- Default: `false`
**Required Parameters Example**:
```json
{
"model": "baidu/ERNIE-Image-Turbo/text-to-image",
"prompt": ""
}
```
**Full Example**:
```json
{
"model": "baidu/ERNIE-Image-Turbo/text-to-image",
"prompt": "",
"size": "1024x1024",
"n": 1,
"seed": -1,
"use_pe": true,
"num_inference_steps": 8,
"guidance_scale": 1,
"enable_sync_mode": false,
"enable_base64_output": false
}
```
### Output Schema
The API returns the following output format:
- **`created_at`** (`string`, _optional_):
ISO timestamp of when the request was created.
- **`has_nsfw_contents`** (`array[boolean]`, _optional_):
Array of boolean values indicating NSFW detection for each output.
- **`id`** (`string`, _optional_):
Unique identifier for the prediction.
- **`model`** (`string`, _optional_):
Model ID used for the prediction.
- **`outputs`** (`array[string]`, _optional_):
Array of URLs to the generated content (empty when status is not completed).
- **`status`** (`string`, _optional_):
Status of the task: created, processing, completed, or failed.
- **`urls`** (`object`, _optional_):
Object containing related API endpoints.
**Example Response**:
```json
{
"created_at": "",
"has_nsfw_contents": [],
"id": "",
"model": "",
"outputs": [
""
],
"status": "",
"urls": {}
}
```
## Usage Examples
### cURL
```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateImage" \
-H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "baidu/ERNIE-Image-Turbo/text-to-image",
"prompt": "",
"size": "1024x1024",
"n": 1,
"seed": -1,
"use_pe": true,
"num_inference_steps": 8,
"guidance_scale": 1,
"enable_sync_mode": false,
"enable_base64_output": false
}'
# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}
# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
-H "Authorization: Bearer $ATLASCLOUD_API_KEY"
# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```
## Additional Resources
### Documentation
- [Model Playground](https://www.atlascloud.ai/models/baidu/ERNIE-Image-Turbo/text-to-image)
Cinematic night city scene, towering skyscrapers under deep blue sky, warm window lights forming patterns across the skyline, cars streaming through avenues with glowing headlights, soft fog drifting between buildings, dramatic lighting, wide angle lens, anamorphic cinematic style, ultra detailed, 8k
Cinematic night city scene, towering skyscrapers under deep blue sky, warm window lights forming patterns across the skyline, cars streaming through avenues with glowing headlights, soft fog drifting between buildings, dramatic lighting, wide angle lens, anamorphic cinematic style, ultra detailed, 8k