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

# Image inputs

> Send image inputs to the Responses API.

## Image input

Send an image for the model to describe, analyze, or answer questions about.
Provide the image as a URL, a base64 data URI, or a previously uploaded `file_id`.

### Image via URL

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  import { SDK } from '@meetkai/mka1';
  import { readFileSync } from 'fs';

  const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

  const result = await sdk.llm.responses.create({
    xOnBehalfOf: '<end-user-id>', // optional — attribute the request to one of your end users
    responsesCreateRequest: {
      model: 'auto',
      input: [
        {
          type: 'message',
          role: 'user',
          content: [
            { type: 'input_text', text: 'Describe what you see in this image.' },
            {
              type: 'input_image',
              imageUrl: 'https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg',
            },
          ],
        },
      ],
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai';
  import { readFileSync } from 'fs';

  const openai = new OpenAI({
    apiKey: '<mka1-api-key>',
    baseURL: 'https://apigw.mka1.com/api/v1/llm/',
    defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  const response = await openai.responses.create({
    model: 'auto',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Describe what you see in this image.' },
          {
            type: 'input_image', detail: 'auto',
            image_url: 'https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg',
          },
        ],
      },
    ],
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  from meetkai_mka1 import SDK
  import base64

  sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

  result = sdk.llm.responses.create(
      model="auto",
      input=[{
          "type": "message",
          "role": "user",
          "content": [
              {"type": "input_text", "text": "Describe what you see in this image."},
              {
                  "type": "input_image",
                  "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
              },
          ],
      }],
  )
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(bearerAuth: "Bearer <mka1-api-key>");

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
      {
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.User,
              Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                  new List<InputMessageContent>
                  {
                      InputMessageContent.CreateInputText(new InputText()
                      {
                          Text = "Describe what you see in this image.",
                      }),
                      InputMessageContent.CreateInputImage(new InputImage()
                      {
                          ImageUrl = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
                      }),
                  }),
          }),
      }),
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create \
    -H 'X-On-Behalf-Of: <end-user-id>' \
    --body '{
      "model": "auto",
      "input": [
        {
          "type": "message",
          "role": "user",
          "content": [
            { "type": "input_text", "text": "Describe what you see in this image." },
            {
              "type": "input_image",
              "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
            }
          ]
        }
      ]
    }'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "input": [
        {
          "type": "message",
          "role": "user",
          "content": [
            { "type": "input_text", "text": "Describe what you see in this image." },
            {
              "type": "input_image",
              "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg",
            }
          ]
        }
      ]
    }'
  ```
</CodeGroup>

### Image via base64

Encode the image as a data URI with the appropriate MIME type.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const imageBase64 = readFileSync('photo.jpg').toString('base64');

  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      input: [
        {
          type: 'message',
          role: 'user',
          content: [
            { type: 'input_text', text: 'What is in this photo?' },
            {
              type: 'input_image',
              imageUrl: `data:image/jpeg;base64,${imageBase64}`,
            },
          ],
        },
      ],
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const imageBase64 = readFileSync('photo.jpg').toString('base64');

  const response = await openai.responses.create({
    model: 'auto',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'What is in this photo?' },
          {
            type: 'input_image', detail: 'auto',
            image_url: `data:image/jpeg;base64,${imageBase64}`,
          },
        ],
      },
    ],
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  with open("photo.jpg", "rb") as f:
      image_base64 = base64.b64encode(f.read()).decode()

  result = sdk.llm.responses.create(
      model="auto",
      input=[{
          "type": "message",
          "role": "user",
          "content": [
              {"type": "input_text", "text": "What is in this photo?"},
              {
                  "type": "input_image",
                  "image_url": f"data:image/jpeg;base64,{image_base64}",
              },
          ],
      }],
  )
  ```

  ```csharp C# SDK theme={null}
  var imageBytes = System.IO.File.ReadAllBytes("photo.jpg");
  var imageBase64 = Convert.ToBase64String(imageBytes);

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
      {
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.User,
              Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                  new List<InputMessageContent>
                  {
                      InputMessageContent.CreateInputText(new InputText()
                      {
                          Text = "What is in this photo?",
                      }),
                      InputMessageContent.CreateInputImage(new InputImage()
                      {
                          ImageUrl = $"data:image/jpeg;base64,{imageBase64}",
                      }),
                  }),
          }),
      }),
  });
  ```

  ```bash CLI theme={null}
  IMAGE_B64=$(base64 -i photo.jpg)

  mka1 llm responses create \
    --body "{
      \"model\": \"auto\",
      \"input\": [
        {
          \"type\": \"message\",
          \"role\": \"user\",
          \"content\": [
            { \"type\": \"input_text\", \"text\": \"What is in this photo?\" },
            {
              \"type\": \"input_image\",
              \"image_url\": \"data:image/jpeg;base64,${IMAGE_B64}\"
            }
          ]
        }
      ]
    }"
  ```

  ```bash Bash theme={null}
  # Encode a local image and send it inline
  IMAGE_B64=$(base64 -i photo.jpg)

  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --data "{
      \"model\": \"auto\",
      \"input\": [
        {
          \"type\": \"message\",
          \"role\": \"user\",
          \"content\": [
            { \"type\": \"input_text\", \"text\": \"What is in this photo?\" },
            {
              \"type\": \"input_image\",
              \"image_url\": \"data:image/jpeg;base64,${IMAGE_B64}\"
            }
          ]
        }
      ]
    }"
  ```
</CodeGroup>

### Image via file\_id

Upload an image with the Files API first, then reference it by ID.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const imageBuffer = readFileSync('photo.jpg');

  // Upload the image
  const uploadResult = await sdk.llm.files.upload({
    requestBody: {
      file: { fileName: 'photo.jpg', content: imageBuffer },
      purpose: 'assistants',
    },
  });

  // Use the file_id in a response
  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      input: [
        {
          type: 'message',
          role: 'user',
          content: [
            { type: 'input_text', text: 'Describe this image.' },
            { type: 'input_image', fileId: uploadResult.id },
          ],
        },
      ],
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const imageBuffer = readFileSync('photo.jpg');

  // Upload the image
  const file = await openai.files.create({
    file: new File([imageBuffer], 'photo.jpg', { type: 'image/jpeg' }),
    purpose: 'assistants',
  });

  // Use the file_id in a response
  const response = await openai.responses.create({
    model: 'auto',
    input: [
      {
        type: 'message',
        role: 'user',
        content: [
          { type: 'input_text', text: 'Describe this image.' },
          { type: 'input_image', detail: 'auto', file_id: file.id },
        ],
      },
    ],
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  # Upload the image
  upload_result = sdk.llm.files.upload(
      file={"file_name": "photo.jpg", "content": open("photo.jpg", "rb")},
      purpose="assistants",
  )

  # Use the file_id in a response
  result = sdk.llm.responses.create(
      model="auto",
      input=[{
          "type": "message",
          "role": "user",
          "content": [
              {"type": "input_text", "text": "Describe this image."},
              {"type": "input_image", "file_id": upload_result.id},
          ],
      }],
  )
  ```

  ```csharp C# SDK theme={null}
  // Upload the image
  var uploadResult = await sdk.Llm.Files.UploadAsync(new UploadFileRequestBody()
  {
      File = new UploadFileFile()
      {
          FileName = "photo.png",
          Content = System.IO.File.ReadAllBytes("photo.png"),
      },
      Purpose = UploadFilePurpose.Assistants,
  });

  // Use the file_id in a response
  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
      {
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.User,
              Content = InputMessageContent1.CreateArrayOfInputMessageContent(
                  new List<InputMessageContent>
                  {
                      InputMessageContent.CreateInputText(new InputText()
                      {
                          Text = "Describe this image.",
                      }),
                      InputMessageContent.CreateInputImage(new InputImage()
                      {
                          FileId = uploadResult.File!.Id,
                      }),
                  }),
          }),
      }),
  });
  ```

  ```bash CLI theme={null}
  # Upload the image
  FILE_ID=$(mka1 llm files upload \
    --file @photo.jpg \
    --purpose assistants | jq -r '.id')

  # Use the file_id
  mka1 llm responses create \
    --body "{
      \"model\": \"auto\",
      \"input\": [
        {
          \"type\": \"message\",
          \"role\": \"user\",
          \"content\": [
            { \"type\": \"input_text\", \"text\": \"Describe this image.\" },
            { \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
          ]
        }
      ]
    }"
  ```

  ```bash Bash theme={null}
  # Upload the image
  FILE_ID=$(curl -s https://apigw.mka1.com/api/v1/llm/files \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --form file=@photo.jpg \
    --form purpose=assistants | jq -r '.id')

  # Use the file_id
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --data "{
      \"model\": \"auto\",
      \"input\": [
        {
          \"type\": \"message\",
          \"role\": \"user\",
          \"content\": [
            { \"type\": \"input_text\", \"text\": \"Describe this image.\" },
            { \"type\": \"input_image\", \"file_id\": \"${FILE_ID}\" }
          ]
        }
      ]
    }"
  ```
</CodeGroup>

## Combine input types

See [Multimodal input](/docs/multimodal-input#mixed-input) for a request containing several input types.