> ## 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.
# टेक्स्ट से इमेज
> Krea API के टेक्स्ट-टू-इमेज मॉडल्स — Krea 2, Flux, Nano Banana Pro, और अधिक — की तुलना करें, प्राइसिंग, क्षमताओं, और कोड नमूनों के साथ सही मॉडल चुनने के लिए।
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 &&
}
{}
{}
{}
***
## अवलोकन
Flux, Nano Banana Pro, और अन्य अत्याधुनिक AI मॉडलों का उपयोग करके टेक्स्ट विवरण से इमेज जनरेट करें। यह उदाहरण आपको जनरेशन अनुरोध सबमिट करने से लेकर अंतिम इमेज प्राप्त करने तक के पूरे वर्कफ़्लो के बारे में बताता है।
इमेज जनरेशन एसिंक्रोनस है। आपको तुरंत एक job ID मिलेगी, फिर आपको इमेज तैयार होने तक परिणामों के लिए पोल करना होगा।
## इंटरैक्टिव प्लेग्राउंड
यहाँ विभिन्न भाषाओं में एक पूरा उदाहरण दिया गया है:
```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"
```
**अपने API टोकन से बदलें**
ऊपर दिए गए उदाहरणों में YOUR\_API\_TOKEN प्लेसहोल्डर को बदलने के लिए, आपको [krea.ai/settings/api-tokens](https://www.krea.ai/settings/api-tokens) में एक API टोकन जनरेट करना होगा। यदि आपको सहायता चाहिए, तो [API Keys & Billing](/developers/api-keys-and-billing) पेज पर दिए गए निर्देशों का पालन करें।
सभी उपलब्ध मॉडलों को खोजने के लिए, [Model APIs](/api-reference/introduction) पेज देखें।
***
## विवरण
नीचे, हम आपको जनरेशन अनुरोध सबमिट करने से लेकर अंतिम इमेज प्राप्त करने तक के पूरे वर्कफ़्लो के बारे में बताएँगे।
## चरण 1: एक इमेज जनरेशन जॉब बनाएँ
अपने प्रॉम्प्ट और पैरामीटर के साथ `/generate/image/bfl/flux-1-dev` पर एक POST अनुरोध करें। API तुरंत एक job ID लौटाता है—जनरेशन एसिंक्रोनस रूप से होता है।
```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"])
}
```
**उदाहरण प्रतिक्रिया**
```json theme={null}
{
"job_id": "550e8400-e29b-41d4-a716-446655440000",
"status": "queued",
"created_at": "2025-01-15T10:30:00.000Z"
}
```
***
## चरण 2: परिणामों के लिए पोल करें
जॉब पूरा होने तक हर 2 सेकंड में `/jobs/{job_id}` को पोल करें। Krea API कुछ मॉडलों के लिए मध्यवर्ती जनरेशन आउटपुट प्रदान करता है।
```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)
}
}
```
**वेबहुक उपलब्ध हैं!**
जब जॉब पूरे हो जाएँ तो सूचनाएँ प्राप्त करने के लिए वेबहुक सेट अप करें। शुरू करने के लिए [Webhooks guide](/developers/webhooks) देखें।
सभी मॉडलों के विस्तृत पैरामीटर की सूची के लिए, [Model APIs](/api-reference/introduction) पेज देखें।
**उदाहरण पूर्ण प्रतिक्रिया**
```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"
]
}
}
```
सभी संभावित जॉब स्टेटस और पूर्ण जॉब लाइफ़साइकिल के बारे में जानने के लिए, [Job Lifecycle](/developers/job-lifecycle) पेज देखें।
}