> ## Documentation Index
> Fetch the complete documentation index at: https://www.krea.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Text to Image
> Confronta i modelli text-to-image della Krea API — Krea 2, Flux, Nano Banana Pro e altri — con prezzi, capacità ed esempi di codice per scegliere quello giusto.
export const ModelOverviewCard = ({name, description, icon, href}) => {
const resolvedIcon = (() => {
if (typeof icon !== "string" || !icon.startsWith("/") || icon.startsWith("//")) return icon;
if (typeof window === "undefined") return icon;
const base = "/docs";
const under = window.location.pathname === base || window.location.pathname.startsWith(base + "/");
return under && !icon.startsWith(base + "/") ? base + icon : icon;
})();
return
{}
{icon &&
}
;
};
export const HeroHeader = ({image, video, title, description}) => {
return
{}
{video &&
}
{}
{}
{}
***
## Panoramica
Genera immagini a partire da descrizioni testuali usando Flux, Nano Banana Pro e altri modelli di IA all’avanguardia. Questo esempio ti guida attraverso il flusso completo, dalla richiesta di generazione al recupero dell’immagine finale.
La generazione di immagini è asincrona. Riceverai immediatamente un job ID, poi effettuerai polling per i risultati finché l’immagine non è pronta.
## Playground interattivo
Ecco un esempio completo in diversi linguaggi:
```javascript Node.js theme={null}
// npm install @krea-ai/sdk
import { Krea } from "@krea-ai/sdk";
const krea = new Krea({ apiKey: process.env.KREA_API_KEY });
const result = await krea.subscribe("image/bfl/flux-1-dev", {
input: {
prompt: "a serene mountain landscape at sunset",
width: 1024,
height: 576,
steps: 28
}
});
console.log(`Image ready: ${result.data?.urls[0]}`);
```
```python Python theme={null}
import requests
import time
API_BASE = "https://api.krea.ai"
API_TOKEN = "your-token-secret"
# Step 1: Create generation job
response = requests.post(
f"{API_BASE}/generate/image/bfl/flux-1-dev",
headers={
"Authorization": f"Bearer {API_TOKEN}",
"Content-Type": "application/json"
},
json={
"prompt": "a serene mountain landscape at sunset",
"width": 1024,
"height": 576,
"steps": 28
}
)
job = response.json()
job_id = job["job_id"]
# Step 2: Poll for completion
while True:
response = requests.get(
f"{API_BASE}/jobs/{job_id}",
headers={"Authorization": f"Bearer {API_TOKEN}"}
)
job = response.json()
if job["status"] == "completed":
image_url = job["result"]["urls"][0]
print(f"Image ready: {image_url}")
break
if job["status"] in ("failed", "cancelled"):
raise Exception(f"Job failed: {job['status']}")
print(f"Status: {job['status']}")
time.sleep(2)
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"time"
)
func main() {
apiBase := "https://api.krea.ai"
apiToken := "your-token-secret"
client := &http.Client{}
// Step 1: Create generation job
payload := map[string]interface{}{
"prompt": "a serene mountain landscape at sunset",
"width": 1024,
"height": 576,
"steps": 28,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", apiBase+"/generate/image/bfl/flux-1-dev", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer "+apiToken)
req.Header.Set("Content-Type", "application/json")
resp, _ := client.Do(req)
var job map[string]interface{}
json.NewDecoder(resp.Body).Decode(&job)
resp.Body.Close()
jobID := job["job_id"].(string)
// Step 2: Poll for completion
for {
req, _ := http.NewRequest("GET", apiBase+"/jobs/"+jobID, nil)
req.Header.Set("Authorization", "Bearer "+apiToken)
resp, _ := client.Do(req)
var jobStatus map[string]interface{}
json.NewDecoder(resp.Body).Decode(&jobStatus)
resp.Body.Close()
switch jobStatus["status"] {
case "completed":
result := jobStatus["result"].(map[string]interface{})
imageURL := result["urls"].([]interface{})[0].(string)
fmt.Printf("Image ready: %s\n", imageURL)
return
case "failed", "cancelled":
fmt.Printf("Job failed: %s\n", jobStatus["status"])
return
}
fmt.Printf("Status: %s\n", jobStatus["status"])
time.Sleep(2 * time.Second)
}
}
```
```bash cURL theme={null}
# Step 1: Create generation job
curl -X POST https://api.krea.ai/generate/image/bfl/flux-1-dev \
-H "Authorization: Bearer YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"prompt": "a serene mountain landscape at sunset",
"width": 1024,
"height": 576,
"steps": 28
}'
# Response: {"job_id": "550e8400-e29b-41d4-a716-446655440000", ...}
# Step 2: Poll for completion (repeat until completed)
curl -X GET https://api.krea.ai/jobs/550e8400-e29b-41d4-a716-446655440000 \
-H "Authorization: Bearer YOUR_API_TOKEN"
```
**Sostituisci con il tuo token API**
Per sostituire il segnaposto YOUR\_API\_TOKEN negli esempi qui sopra, dovrai generare un token API su [krea.ai/settings/api-tokens](https://www.krea.ai/settings/api-tokens). Segui le istruzioni nella pagina [Chiavi API e fatturazione](/developers/api-keys-and-billing) se hai bisogno di aiuto.
Per trovare tutti i modelli disponibili, consulta la pagina [Model APIs](/api-reference/introduction).
***
## Approfondimento
Di seguito ti guidiamo attraverso il flusso completo, dall’invio della richiesta di generazione al recupero dell’immagine finale.
## Step 1: Crea un job di generazione immagine
Effettua una richiesta POST a `/generate/image/bfl/flux-1-dev` con il tuo prompt e i parametri. L’API restituisce immediatamente un job ID — la generazione avviene in modo asincrono.
```javascript Node.js theme={null}
// npm install @krea-ai/sdk
import { Krea } from "@krea-ai/sdk";
const krea = new Krea({ apiKey: process.env.KREA_API_KEY });
const job = await krea.image("bfl/flux-1-dev", {
prompt: "a serene mountain landscape at sunset",
width: 1024,
height: 576,
steps: 28
});
console.log(`Job ID: ${job.job_id}`);
```
```bash cURL theme={null}
curl -X POST https://api.krea.ai/generate/image/bfl/flux-1-dev \
-H "Authorization: Bearer YOUR_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"prompt": "a serene mountain landscape at sunset",
"width": 1024,
"height": 576,
"steps": 28
}'
```
```python Python theme={null}
import requests
API_BASE = "https://api.krea.ai"
API_TOKEN = "your-token-secret"
response = requests.post(
f"{API_BASE}/generate/image/bfl/flux-1-dev",
headers={
"Authorization": f"Bearer {API_TOKEN}",
"Content-Type": "application/json"
},
json={
"prompt": "a serene mountain landscape at sunset",
"width": 1024,
"height": 576,
"steps": 28
}
)
job = response.json()
print(f"Job ID: {job['job_id']}")
```
```go Go theme={null}
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)
func main() {
apiBase := "https://api.krea.ai"
apiToken := "your-token-secret"
payload := map[string]interface{}{
"prompt": "a serene mountain landscape at sunset",
"width": 1024,
"height": 576,
"steps": 28,
}
jsonData, _ := json.Marshal(payload)
req, _ := http.NewRequest("POST", apiBase+"/generate/image/bfl/flux-1-dev", bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer "+apiToken)
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
var job map[string]interface{}
json.NewDecoder(resp.Body).Decode(&job)
fmt.Printf("Job ID: %s\n", job["job_id"])
}
```
**Esempio di risposta**
```json theme={null}
{
"job_id": "550e8400-e29b-41d4-a716-446655440000",
"status": "queued",
"created_at": "2025-01-15T10:30:00.000Z"
}
```
***
## Step 2: Effettua il polling per i risultati
Effettua polling su `/jobs/{job_id}` ogni 2 secondi finché il job non si completa. La Krea API fornisce output intermedi di generazione per alcuni modelli.
```javascript Node.js theme={null}
// npm install @krea-ai/sdk
import { Krea } from "@krea-ai/sdk";
const krea = new Krea({ apiKey: process.env.KREA_API_KEY });
async function waitForJob(jobId) {
const completed = await krea.jobs.wait(jobId, { intervalMs: 2000 });
return completed.result.urls[0];
}
const imageUrl = await waitForJob(job.job_id);
console.log(`Image ready: ${imageUrl}`);
```
```bash cURL theme={null}
# Check job status
curl -X GET https://api.krea.ai/jobs/YOUR_JOB_ID \
-H "Authorization: Bearer YOUR_API_TOKEN"
```
```python Python theme={null}
import time
def wait_for_job(job_id):
while True:
response = requests.get(
f"{API_BASE}/jobs/{job_id}",
headers={"Authorization": f"Bearer {API_TOKEN}"}
)
job = response.json()
if job["status"] == "completed":
return job["result"]["urls"][0]
if job["status"] in ("failed", "cancelled"):
raise Exception(f"Job failed: {job['status']}")
print(f"Status: {job['status']}")
time.sleep(2)
image_url = wait_for_job(job["job_id"])
print(f"Image ready: {image_url}")
```
```go Go theme={null}
func waitForJob(jobID string) (string, error) {
for {
req, _ := http.NewRequest("GET", apiBase+"/jobs/"+jobID, nil)
req.Header.Set("Authorization", "Bearer "+apiToken)
resp, _ := client.Do(req)
var job map[string]interface{}
json.NewDecoder(resp.Body).Decode(&job)
resp.Body.Close()
switch job["status"] {
case "completed":
result := job["result"].(map[string]interface{})
urls := result["urls"].([]interface{})
return urls[0].(string), nil
case "failed", "cancelled":
return "", fmt.Errorf("job failed: %s", job["status"])
}
fmt.Printf("Status: %s\n", job["status"])
time.Sleep(2 * time.Second)
}
}
```
**Webhook disponibili!**
Configura i webhook per ricevere notifiche al completamento dei job. Consulta la [guida ai Webhook](/developers/webhooks) per iniziare.
Per l’elenco dettagliato dei parametri di tutti i modelli, consulta la pagina [Model APIs](/api-reference/introduction).
**Esempio di risposta completata**
```json theme={null}
{
"job_id": "550e8400-e29b-41d4-a716-446655440000",
"status": "completed",
"created_at": "2025-01-15T10:30:00.000Z",
"completed_at": "2025-01-15T10:30:25.000Z",
"result": {
"urls": [
"https://krea.ai/generations/your-image.png"
]
}
}
```
Per conoscere tutti gli stati possibili dei job e l’intero ciclo di vita, consulta la pagina [Ciclo di vita del job](/developers/job-lifecycle).
}