Image Generation - Mesh API

Generate an image

Python
Node.js
Go

import base64
from meshapi import MeshAPI, ImageGenerationParams

client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")

resp = client.images.generate(
    ImageGenerationParams(
        model="openai/gpt-image-1",
        prompt="A small blue square on a white background.",
        n=1,
        size="1024x1024",
    )
)

print(resp.created)          # Unix timestamp
print(len(resp.data))        # number of images
# each item has either .b64_json or .url
if resp.data[0].b64_json:
    image_bytes = base64.b64decode(resp.data[0].b64_json)
elif resp.data[0].url:
    print(resp.data[0].url)

const resp = await client.images.generate({
  model: "openai/gpt-image-1",
  prompt: "A small blue square on a white background.",
  n: 1,
  size: "1024x1024",
});

console.log(resp.created);    // Unix timestamp
if (resp.data[0].b64_json) {
  const bytes = Buffer.from(resp.data[0].b64_json, "base64");
} else if (resp.data[0].url) {
  console.log(resp.data[0].url);
}

model := "openai/gpt-image-1"
n := 1
size := "1024x1024"

resp, err := client.Images.Generate(ctx, meshapi.ImageGenerationParams{
    Model:  &model,
    Prompt: "A small blue square on a white background.",
    N:      &n,
    Size:   &size,
})
if err != nil {
    log.Fatal(err)
}

fmt.Printf("created=%d images=%d\n", resp.Created, len(resp.Data))
if resp.Data[0].B64JSON != nil {
    // base64 image data
} else if resp.Data[0].URL != nil {
    fmt.Println(*resp.Data[0].URL)
}

Getting the image bytes

Where the image data lands depends on the model and response_format. With the default (or response_format="url"), some models — including openai/gpt-image-1 — return the image inline as a data: URI in url rather than in b64_json. Pass response_format="b64_json" to always get base64 in b64_json, or use the helper below to get raw bytes regardless of shape:

Python
Go

# handles b64_json OR a data: URI in url
image_bytes = resp.data[0].image_bytes()
with open("out.png", "wb") as f:
    f.write(image_bytes)

imageBytes, err := resp.Data[0].Bytes() // handles B64JSON or a data: URI in URL
if err != nil {
    log.Fatal(err)
}
os.WriteFile("out.png", imageBytes, 0644)

Both raise/return an error if url is a remote http(s) link (fetch it yourself).

Edit an image

images.edit() calls POST /v1/images/edits with a JSON body. Pass the source image (and an optional mask or reference_images) as a data:image/...;base64, URL or a bare base64 string; remote http(s) URLs are rejected with 422. The response has the same shape as a generation. See Image Generation: Edit an image for the operations each provider supports.

Python
Node.js
Go

import base64
from meshapi import ImageEditParams

with open("cat.png", "rb") as f:
    image = "data:image/png;base64," + base64.b64encode(f.read()).decode()

edited = client.images.edit(
    ImageEditParams(model="openai/gpt-image-1", image=image, prompt="Add a party hat on the cat")
)
edited_bytes = edited.data[0].image_bytes()

import { readFileSync } from "node:fs";

const image = "data:image/png;base64," + readFileSync("cat.png").toString("base64");

const edited = await client.images.edit({
  model: "openai/gpt-image-1",
  image,
  prompt: "Add a party hat on the cat",
});

raw, err := os.ReadFile("cat.png")
if err != nil {
    log.Fatal(err)
}
image := "data:image/png;base64," + base64.StdEncoding.EncodeToString(raw)
prompt := "Add a party hat on the cat"

edited, err := client.Images.Edit(ctx, meshapi.ImageEditParams{
    Model:  "openai/gpt-image-1",
    Image:  image,
    Prompt: &prompt,
})
if err != nil {
    log.Fatal(err)
}
editedBytes, err := edited.Data[0].Bytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("cat-hat.png", editedBytes, 0644)

For streaming generation, images.stream() (Images.Stream in Go) sends stream: true and yields image chunks. See Image Generation: Streaming.

Response fields

Field	Description
`resp.created`	Unix timestamp of when the image was created
`resp.data`	Array of image objects
`resp.data[i].b64_json`	Base64-encoded image (if returned as base64)
`resp.data[i].url`	Image URL — may be a hosted link or an inline `data:` URI
`resp.data[i].image_bytes()` / `.Bytes()`	Raw image bytes from either shape (Python / Go)

openai/gpt-image-1 is the recommended image generation model. Additional image generation models may be available depending on your account.

​Generate an image

​Getting the image bytes

​Edit an image

​Response fields

Generate an image

Getting the image bytes

Edit an image

Response fields