Source: https://ailoot.ai/models/sv/grok-imagine-image/
Canonical: https://ailoot.ai/models/sv/grok-imagine-image/
Language: sv

# grok-imagine-image

[Markdown](https://ailoot.ai/models/sv/grok-imagine-image/index.md) · [JSON](https://ailoot.ai/models/sv/grok-imagine-image/facts.json)

## [grok-imagine-image](https://ailoot.ai/models/sv/grok-imagine-image/)

Grok Imagine Image skapar bilder från textbeskrivningar med val av bildformat och upplösning i 1K eller 2K. Passar för kvadratiskt, stående och bredbildsmaterial.

- [**Ailoot · Bilder** `POST /v1/images/generations` `grok-imagine-image`](https://ailoot.ai/models/sv/grok-imagine-image/#method-0)

Om modellen

Den här beskrivningen omfattar modellens förmågor. Tillgängliga indata, utdata och alternativ i Ailoot anges nedan för den valda metoden.

Grok Imagine Image är en modell från xAI för visuell generering. Den omvandlar en textbeskrivning av en scen till en bild. Modellen själv har även visuell indata för arbete med en ursprungsbild. Ailoots publicerade genereringsmetod använder en textförfrågan som indata.

#### Varianter av samma idé

Ett anrop kan ange från **1 till 10 bilder** med parametern `n`. Om antalet inte anges skapas en bild. Det är praktiskt när flera varianter av samma beskrivning behövs. Olika fristående scener anges med separata beskrivningar.

#### Bildformat och upplösning

Kvadratiskt `1:1`, liggande `16:9`, stående `9:16`, formaten `4:3` och `3:4` samt fotografiska `3:2` och `2:3` kan väljas. Läget `auto` låter modellen välja proportioner utifrån beskrivningen och används som standard.

Generering erbjuder **1K och 2K**. Utan uttryckligt val används 1K. Upplösning och bildförhållande ställs in separat. Den första bestämmer bildstorleken och det andra bildformen.

#### Arbete med visuellt material

I xAI:s visuella läge kompletteras ursprungsbilden med en textinstruktion som anger ändring av scenens innehåll eller utseende. Ett redigeringsresultat kan användas i nästa redigering för stegvis detaljförfining. Modellens eget läge skiljer sig från den publicerade textbaserade genereringen.

Modellen returnerar en bild. Resultatet kan överföras som en fil via länk eller som bilddata i base64. Möjligheten att välja `quality` med värdena `low`, `medium` och `auto` gäller Image 2.0 och överförs inte till Grok Imagine Image.

**Ailoot · Bilder** `POST /v1/images/generations` `grok-imagine-image`

[`grok-imagine-image`](https://ailoot.ai/models/sv/#m=grok-imagine-image&route=Core&caller=grok-imagine-image&fmt=images)

xAI /`grok-imagine-image`

### Start

Grok Imagine Image skapar bilder från textbeskrivningar med val av bildformat och upplösning i 1K eller 2K. Passar för kvadratiskt, stående och bredbildsmaterial.

Godkända indata

Text

Resultat

Bilder

### Tillgängligt i Ailoot · indata & metoder

**Ailoot · Bilder** `POST /v1/images/generations`

Indatatyper

`text`

Utdatatyper

`image`

Utdataformat

Bildfil

| Fält | Typ | Krav | Värden & gränser | Standard |
| --- | --- | --- | --- | --- |
| Fält`model` | Typ`string` | KravObligatoriskt | Värden & gränser grok-imagine-image | Standard— |
| Fält`prompt` | Typ`string` | KravObligatoriskt | Värden & gränser | Standard— |
| Fält`n` | Typ`integer` | KravValfritt | Värden & gränser Minimum: 1 Maximum: 10 | Standard1 |
| Fält`response_format` | Typ`string` | KravValfritt | Värden & gränser url, b64\_json | Standardurl |
| Fält`resolution` | Typ`string` | KravValfritt | Värden & gränser 1k, 2k | Standard1k |
| Fält`aspect_ratio` | Typ`string` | KravValfritt | Värden & gränser auto, 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 2:1, 1:2, 19.5:9, 9:19.5, 20:9, 9:20, 21:9, 5:2 | Standardauto |
| Fält`quality` | Typ`string` | KravStöds inte | Värden & gränser | Standard— |

Kombinationer av indatamaterial

**Text till bild** · Krävs: prompt

Metodparametrar och livscykel

| Parameter | Avtal |
| --- | --- |
| Parameter`material_types` | Avtaltext |
| Parameter`required` | Avtalmodel, prompt |
| Parameter`optional_controls` | Avtalnull |
| Parameter`content_type` | Avtalapplication/json |

Livscykel: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · Det task\_id som faktiskt returnerades eller en post i mediebiblioteket

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

Metodernas strukturer och ID:n är exakta; leverantörens funktioner är åtskilda från att begäran tillåts.

### Priser

#### Priser för Ailoot-metoder

Indata

0,002 US$ *per indatabild*

Utdata

0,02 US$ *per bild i 1K*

Utdata

0,02 US$ *per bild i 2K*

Ailoot reserverar ett uppskattat belopp före en begäran. Efter resultatet slutregleras avgiften utifrån uppmätt förbrukning. Slutreglering för strömning använder den slutliga förbrukningsposten. [Så fungerar reservation och slutreglering →](https://ailoot.ai/docs/sv/billing/reserve/)

### Exempelbegäranden

#### Ailoot · Bilder

curlPython SDKNode.js SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
export AILOOT_API_KEY
export AILOOT_API_KEY
: "${AILOOT_PROMPT_FILE:?Set your actual UTF-8 image brief}"
export AILOOT_PROMPT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-imagine-image", "prompt": ""}')
f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 brief")
p['prompt']=f.read_text(encoding="utf-8")
if not p['prompt'].strip():raise SystemExit("Brief must contain text")
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/images/generations \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json, os, subprocess
from pathlib import Path
from urllib.parse import urlsplit, urljoin

def save_images(items):
    if not items: raise SystemExit("No completed images; retain the full response")
    for index, item in enumerate(items):
        encoded=item.get("b64_json")
        uri=item.get("url", "")
        if not encoded and uri.startswith("data:image/"):
            header, separator, encoded=uri.partition(",")
            if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI")
        if encoded:
            raw=base64.b64decode(encoded,validate=True)
        elif uri:
            uri=urljoin("https://api.ailoot.ai",uri)
            parsed=urlsplit(uri)
            if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password:
                raise SystemExit("Invalid returned image URL")
            owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content")
            args=["curl","--fail-with-body","--silent","--show-error",uri]
            if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]]
            temporary=Path(f"image-{index}.bin")
            subprocess.run(args+["-o",str(temporary)],check=True)
            raw=temporary.read_bytes()
            temporary.unlink()
        else: raise SystemExit("Image has neither bytes nor URL")
        if not raw: raise SystemExit("Empty image result")
        ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

```python
from openai import OpenAI
import base64, json, os, subprocess
from pathlib import Path
from urllib.parse import urlsplit, urljoin

def save_images(items):
    if not items: raise SystemExit("No completed images; retain the full response")
    for index, item in enumerate(items):
        encoded=item.get("b64_json")
        uri=item.get("url", "")
        if not encoded and uri.startswith("data:image/"):
            header, separator, encoded=uri.partition(",")
            if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI")
        if encoded:
            raw=base64.b64decode(encoded,validate=True)
        elif uri:
            uri=urljoin("https://api.ailoot.ai",uri)
            parsed=urlsplit(uri)
            if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password:
                raise SystemExit("Invalid returned image URL")
            owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content")
            args=["curl","--fail-with-body","--silent","--show-error",uri]
            if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]]
            temporary=Path(f"image-{index}.bin")
            subprocess.run(args+["-o",str(temporary)],check=True)
            raw=temporary.read_bytes()
            temporary.unlink()
        else: raise SystemExit("Image has neither bytes nor URL")
        if not raw: raise SystemExit("Empty image result")
        ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")

f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Set your actual UTF-8 image brief file")
request={'model': 'grok-imagine-image', 'prompt': ''}
request["prompt"]=f.read_text(encoding="utf-8")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.images.generate(**request)
Path("sdk-result.txt").write_text(str(result),encoding="utf-8")
save_images([{"b64_json":getattr(item,"b64_json",None),"url":getattr(item,"url",None)} for item in result.data])
```

```js
import OpenAI from "openai";
import { readFileSync, writeFileSync } from "node:fs";
const key=process.env.AILOOT_API_KEY;
if(!key) throw new Error("Set your actual Ailoot API key");
const client=new OpenAI({baseURL:"https://api.ailoot.ai/v1",apiKey:key,maxRetries:0});
const request={"model": "grok-imagine-image", "prompt": ""};
if(!process.env.AILOOT_PROMPT_FILE)throw new Error("Set your actual UTF-8 image brief file");
request.prompt=readFileSync(process.env.AILOOT_PROMPT_FILE,"utf8");
const result=await client.images.generate(request);
writeFileSync("sdk-result.json",JSON.stringify(result,null,2));
if(!result.data?.length) throw new Error("No completed images");
for(let index=0;index<result.data.length;index++) {
  const item=result.data[index];let encoded=item.b64_json,uri=item.url||"",raw;
  if(!encoded && uri.startsWith("data:image/")) {
    const comma=uri.indexOf(",");if(comma<0 || !uri.slice(0,comma).includes(";base64")) throw new Error("Unsupported image data URI");
    encoded=uri.slice(comma+1);
  }
  if(encoded) {
    if(encoded.length%4!==0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw new Error("Invalid Base64");
    raw=Buffer.from(encoded,"base64");
  } else if(uri) {
    const u=new URL(uri,"https://api.ailoot.ai");
    if(u.protocol!=="https:" || u.username || u.password) throw new Error("Invalid returned URL");
    const owned=u.origin==="https://api.ailoot.ai" && u.pathname.startsWith("/v1/media/assets/") && u.pathname.endsWith("/content");
    const response=await fetch(u,{headers:owned?{Authorization:"Bearer "+key}:{},redirect:"manual"});
    if(!response.ok) throw new Error("Image content download failed: "+response.status);
    raw=Buffer.from(await response.arrayBuffer());
  } else throw new Error("Image has neither bytes nor URL");
  if(!raw.length) throw new Error("Empty image result");
  const ext=raw.subarray(0,4).equals(Buffer.from([137,80,78,71]))?"png":raw[0]===255&&raw[1]===216?"jpg":raw.toString("ascii",0,4)==="RIFF"&&raw.toString("ascii",8,12)==="WEBP"?"webp":raw.toString("utf8").trimStart().startsWith("<svg")||raw.toString("utf8").trimStart().startsWith("<?xml")?"svg":"bin";
  writeFileSync(`image-${index}.${ext}`,raw);
}
console.log("Every returned image saved; sdk-result.json retains complete metadata");
```

### Ta emot och spara resultat

#### Ailoot · Bilder

Ladda ned varje returnerad bild eller spara dess Base64-innehåll

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

##### Behåll alla färdiga resultat

Spara varje färdig bild; hämta varje returnerad URL eller avkoda dess Base64-innehåll.

Spara varje dataobjekt. Avkoda varje b64\_json-värde eller hämta innehållet via varje returnerad signerad URL. Välj filändelse utifrån den faktiska MIME-typen och filens byteinnehåll.

##### Om det ursprungliga svaret behöver kontrolleras

Om resultatet av en bildgenerering eller bildredigering behöver kontrolleras ska du behålla de ursprungliga värdena för operation\_id/X-Client-Request-ID och den returnerade resultatinformationen. Hämta befintliga resultat som tillhör dig genom mediebiblioteket med de faktiska task\_id- eller asset\_id-värdena. Skicka inte genererings- eller redigeringsförfrågan igen och bygg inte en URL för statusavläsning från operation\_id.

Svarsfält

| Fält | Typ |
| --- | --- |
| Fält`created` | Typinteger |
| Fält`data[].url` | Typstring |
| Fält`data[].b64_json` | Typbase64 string |
| Fält`usage` | Typobject |

Fel och nästa steg

| Svar | Villkor | Nästa steg |
| --- | --- | --- |
| Svar400 · `invalid_request_error` | VillkorOgiltiga obligatoriska fält, ogiltig representation av underlaget eller ogiltigt parametervärde | Nästa stegKorrigera de angivna fälten före en ny begäran om att skapa. |
| Svar`server_error` | VillkorDet returnerade svaret anger att operationen eller resultatet behöver kontrolleras | Nästa stegSpara det ursprungliga operations- eller uppgifts-ID som returnerades, förfrågans headers och svaret. Fortsätt att läsa den ursprungliga operationen med de läsmetoder som stöds. Skicka inte skapandeförfrågan igen. |

### Alias

#### Modellalias

**Ailoot** [`grok-imagine-image`](https://ailoot.ai/models/sv/#m=grok-imagine-image&route=Core&caller=grok-imagine-image&fmt=images)

#### Alias för metodsökvägar

Använd metodsökvägarna som visas ovan.

#### Relaterade anropar-ID:n

[`grok-imagine-image`](https://ailoot.ai/models/sv/#m=grok-imagine-image&route=Core&caller=grok-imagine-image&fmt=images)

FAQ · grok-imagine-image

Vilka indata och resultat finns?

`POST /v1/images/generations` · `grok-imagine-image`: `text` → `image`

Vilka fält använder begäran?

`POST /v1/images/generations` · `grok-imagine-image`: `model`, `prompt`, `n`, `response_format`, `resolution`, `aspect_ratio`

Vilka gränser gäller?

`POST /v1/images/generations` · `grok-imagine-image`: `n.minimum`: `1`; `n.maximum`: `10`

Anslut Ailoot till Claude Code, OpenCode, Hermes eller din app.

## Företaget och dess projektportfölj

Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder.

## Köp token med rabatt.

Prenumerationsrabatt för återkommande arbete. Kampanjkoder ger upp till 50% vid tokenköp.

Prenumeration

Välj en rabatterad plan för återkommande anrop.

Kampanjkod upp till 50%

Ange koden vid köpet. Priset räknas om enligt kampanjen.

Kostnader i historiken

Modell, token och belopp sparas för varje anrop.

[Välj prenumeration](https://ailoot.ai/docs/sv/billing/subscriptions/) · [Se modellpriser](https://ailoot.ai/models/sv/)

## Anslut API till produkten som du säljer.

SaaS, appar och botar enligt Ailoots officiella villkor och licensavtal. Begär återförsäljarlicens för vidareförsäljning.

Kommersiell applikation

Bygg text-, bild-, video- och ljudgenerering i tjänstens betalda funktioner.

Återförsäljarlicens

Skicka projektbeskrivning och åtkomstupplägg. Begär skriftliga villkor för användning och vidareförsäljning.

Dokument på webbplatsen

Officiella villkor, licensavtal och databehandlingspolicy finns tillgängliga före anslutning.

[Begär återförsäljarlicens](mailto:support@ailoot.ai) · [Officiella villkor och licensavtal](https://ailoot.ai/legal/offer?lang=sv)

## Ailoot · Företaget och dess projektportfölj





Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll.





Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder.





Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.