> ## Documentation Index
> Fetch the complete documentation index at: https://docs.moxus.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Visión y generación de imágenes

> Usa gpt-5.4 para comprender imágenes o grok-imagine-image para generar imágenes a partir de indicaciones.

Moxus AI admite la comprensión, generación y edición de imágenes. Los formatos de entrada, los tamaños, la cantidad de resultados y los formatos de respuesta varían según el modelo. Esta página usa `gpt-5.4` para la comprensión de imágenes y `grok-imagine-image` para la generación de imágenes.

<Columns cols={2}>
  <Card title="Comprensión de imágenes" icon="scan-eye" href="#image-understanding">
    Envía una URL de imagen pública o lee un archivo local y pásalo como datos en Base64.
  </Card>

  <Card title="Generación de imágenes" icon="wand-sparkles" href="#image-generation">
    Genera una imagen a partir de una indicación y guarda localmente los datos en Base64 devueltos.
  </Card>

  <Card title="Edición de imágenes" icon="image-plus" href="#image-editing">
    Edita una imagen existente cuando el modelo seleccionado lo admita.
  </Card>

  <Card title="Consejos para las indicaciones" icon="text-cursor-input" href="#prompting-tips">
    Describe el tema, el estilo, la composición y las restricciones.
  </Card>
</Columns>

<Tip>
  Si todavía estás ajustando una indicación, elige un modelo de generación de imágenes en la página de conversación web y genera allí primero una imagen de prueba. Una vez confirmados el modelo y la indicación, usa los ejemplos de la API de esta página desde código externo.
</Tip>

<span id="image-understanding" />

## Comprensión de imágenes

La comprensión de imágenes usa el endpoint `chat/completions` compatible con OpenAI. Puedes pasar una URL de imagen pública o codificar una imagen local en Base64 y enviarla como un URI `data:`. Los ejemplos usan `gpt-5.4`.

### Usar una imagen local

Los ejemplos con imágenes locales leen el archivo, lo convierten a Base64 y luego lo envían en la solicitud. En el ejemplo de Python, `IMAGE_PATH = "photo.jpg"` significa que la imagen está en la misma carpeta del proyecto que el archivo de Python y su nombre debe coincidir exactamente, incluyendo la extensión y las mayúsculas o minúsculas. Usa una ruta local completa cuando la imagen esté en otro lugar. El ejemplo de Node.js usa `const IMAGE_PATH = "photo.png"`; coloca la imagen en la misma carpeta del proyecto que el archivo `.mjs` y ejecuta el comando desde esa carpeta. Cambia tanto `IMAGE_PATH` como `IMAGE_MIME_TYPE` cuando el nombre de archivo o el formato sean diferentes.

<Info>
  Para la instalación de dependencias de Python y Node.js, la ejecución de ejemplos y la solución de problemas del entorno, consulta [FAQ](/es/overview/faq).
</Info>

<CodeGroup>
  ```bash cURL theme={null}
  # This example uses a public image URL. For a local image, use the Python or Node.js example.
  curl https://moxus.ai/v1/chat/completions \
    -H "Authorization: Bearer sk-your-key" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-5.4",
      "messages": [
        {
          "role": "user",
          "content": [
            {"type": "text", "text": "Describe this image and list the key details."},
            {
              "type": "image_url",
              "image_url": {
                "url": "https://example.com/photo.jpg"
              }
            }
          ]
        }
      ]
    }'
  ```

  ```python Python theme={null}
  # base64 is a Python standard library module used to turn a local image into text for JSON.
  import base64
  import httpx
  from openai import OpenAI

  # Replace only these values: your API key and the local image filename or full path.
  API_KEY = "sk-your-key"
  IMAGE_PATH = "photo.jpg"
  # Use image/jpeg for JPEG files. Change this to image/png for PNG files.
  IMAGE_MIME_TYPE = "image/jpeg"

  client = OpenAI(
      api_key=API_KEY,
      base_url="https://moxus.ai/v1",
      # Connect directly to Moxus AI without reading system or terminal proxy variables.
      http_client=httpx.Client(trust_env=False, timeout=60.0),
  )

  # Read the local image file and encode it as a Base64 string.
  # "rb" means read in binary mode, which is required for image files.
  with open(IMAGE_PATH, "rb") as image_file:
      image_base64 = base64.b64encode(image_file.read()).decode("utf-8")

  response = client.chat.completions.create(
      model="gpt-5.4",
      messages=[
          {
              "role": "user",
              "content": [
                  {"type": "text", "text": "Describe this image and list the key details."},
                  {
                      "type": "image_url",
                      "image_url": {
                          # This prefix tells the model that the remaining value is Base64 image data.
                          "url": f"data:{IMAGE_MIME_TYPE};base64,{image_base64}",
                      },
                  },
              ],
          }
      ],
  )

  print(response.choices[0].message.content)
  ```

  ```javascript Node.js theme={null}
  import OpenAI from "openai";

  // readFileSync is a Node.js standard library method for reading the local image file.
  import { readFileSync } from "node:fs";

  // Put photo.png in the same project folder as the .mjs file. Change both values when the filename or format differs.
  const API_KEY = "sk-your-key";
  const IMAGE_PATH = "photo.png";
  const IMAGE_MIME_TYPE = "image/png";

  const client = new OpenAI({
    apiKey: API_KEY,
    baseURL: "https://moxus.ai/v1",
  });

  // Convert the local image into a Base64 string so it can be sent in JSON.
  const imageBase64 = readFileSync(IMAGE_PATH).toString("base64");

  const response = await client.chat.completions.create({
    model: "gpt-5.4",
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Describe this image and list the key details." },
          {
            type: "image_url",
            image_url: {
              // This prefix tells the model that the remaining value is Base64 image data.
              url: `data:${IMAGE_MIME_TYPE};base64,${imageBase64}`,
            },
          },
        ],
      },
    ],
  });

  console.log(response.choices[0].message.content);
  ```
</CodeGroup>

<span id="image-generation" />

## Generación de imágenes

La generación de imágenes usa el endpoint `/v1/images/generations` compatible con OpenAI. Los ejemplos usan `grok-imagine-image`. La compatibilidad con el tamaño, la cantidad de resultados y el formato de respuesta varía según el modelo, así que confirma el nombre del modelo y el precio en Model Square antes de integrarlo.

<CodeGroup>
  ```bash cURL theme={null}
  # prompt describes the image. size and n support depends on the selected image model.
  curl https://moxus.ai/v1/images/generations \
    -H "Authorization: Bearer sk-your-key" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "grok-imagine-image",
      "prompt": "A clean product mockup of a smart desk lamp on a white table, soft studio lighting",
      "n": 1,
      "size": "1024x1024"
    }'
  ```

  ```python Python theme={null}
  # base64 is a Python standard library module used to decode the returned image data.
  import base64
  import httpx
  from openai import OpenAI

  client = OpenAI(
      api_key="sk-your-key",
      base_url="https://moxus.ai/v1",
      # Connect directly to Moxus AI without reading system or terminal proxy variables.
      http_client=httpx.Client(trust_env=False, timeout=60.0),
  )

  response = client.images.generate(
      model="grok-imagine-image",
      prompt="A clean product mockup of a smart desk lamp on a white table, soft studio lighting",
      n=1,
      size="1024x1024",
      response_format="b64_json",
  )

  # With response_format="b64_json", the generated image is returned in the b64_json field.
  image_base64 = response.data[0].b64_json

  # Decode the Base64 string and write it as a local PNG file.
  with open("generated-image.png", "wb") as image_file:
      image_file.write(base64.b64decode(image_base64))

  print("Saved image to generated-image.png")
  ```

  ```javascript Node.js theme={null}
  import OpenAI from "openai";

  // writeFileSync is a Node.js standard library method for writing the image file.
  import { writeFileSync } from "node:fs";

  const client = new OpenAI({
    apiKey: "sk-your-key",
    baseURL: "https://moxus.ai/v1",
  });

  const response = await client.images.generate({
    model: "grok-imagine-image",
    prompt: "A clean product mockup of a smart desk lamp on a white table, soft studio lighting",
    n: 1,
    size: "1024x1024",
    response_format: "b64_json",
  });

  // With response_format: "b64_json", the generated image is returned in the b64_json field.
  const imageBase64 = response.data[0].b64_json;

  // Buffer.from(..., "base64") converts the Base64 string back to image bytes.
  writeFileSync("generated-image.png", Buffer.from(imageBase64, "base64"));

  console.log("Saved image to generated-image.png");
  ```
</CodeGroup>

<span id="image-editing" />

## Edición de imágenes

Usa la edición de imágenes para modificar una imagen existente, como reemplazar un fondo, cambiar un área local o ajustar el estilo general. El endpoint, el formato de carga de archivos y los parámetros dependen del modelo seleccionado. Confirma que el modelo admita la edición de imágenes en Model Square antes de llamarlo.

<span id="prompting-tips" />

## Consejos para las indicaciones

* Describe el tema, el estilo, la composición, la iluminación, la paleta de colores y el fondo.
* Indica el uso previsto y las restricciones, como la relación de aspecto o los elementos que se deben mantener o evitar.
* Combina la comprensión de imágenes con [salida estructurada](/es/guide/structured-output) cuando el código posterior necesite campos estables.

## Notas de facturación

* La comprensión de imágenes generalmente cuenta la entrada de imágenes como tokens. Las imágenes más grandes o más detalladas consumen más tokens.
* La generación y edición de imágenes puede facturarse por imagen, por tamaño o por unidades específicas del modelo.

Consulta [modelos y precios](/es/overview/models-and-pricing) para conocer los precios actuales.

## Notas

* Usa únicamente modelos marcados como compatibles con la capacidad requerida en Model Square.
* Las imágenes grandes pueden consumir más tokens o ser rechazadas; comprímelas cuando sea necesario.
* Las URL de las imágenes deben ser de acceso público.

## Próximos pasos