Name: Claude Haiku 4.5 API: Fast Text and Image Chat
Brand: magicapi
SKU: api-magicapi-coding-performance-ai-anthropic-claude-4-5-haiku
Availability: InStock
Author: API Market

Shashank Agarwal

# 💬 Text and Image Chat API (Anthropic Claude Haiku 4.5)

## Overview
Claude Haiku 4.5 is a language model from Anthropic. Its developer describes it as giving similar levels of coding performance at one-third the cost and more than twice the speed.

Send a text `prompt`, an optional `system_prompt` and an optional `image`. The model returns its answer as a list of text chunks; join them in order to get the full response.

## Features
- **Text generation**: answers, explanations, code and drafts from a single `prompt`.
- **System prompt**: set the assistant's role, tone or rules with `system_prompt`.
- **Image input**: send one `image` URL with the prompt to ask about its content.
- **Image size control**: `max_image_resolution` (0.001 to 2 megapixels, default 0.5) scales the image down before it is sent, which reduces its token count.
- **Output length**: `max_tokens` sets the response limit, from 1024 to 64000 tokens (default 8192).

## Use Cases
1. **Coding help**: write, explain or review code from a description in `prompt`.
2. **Image descriptions**: describe screenshots, diagrams or photos, for example to write alt text.
3. **Text tasks**: summarize, rewrite, classify or answer questions about text you paste into the prompt.
4. **Assistants**: give the model a fixed role with `system_prompt` and send each user question as `prompt`.

## Visual Examples
### Example Input
Prompt: "Describe the image in detail"

Image:

![Example input image for Claude Haiku 4.5: three icons on a terracotta background](https://blog.api.market/wp-content/uploads/2026/10/claude-4-5-haiku-input-api-market.png)

Other fields: `max_tokens` `1024`, `system_prompt` `""` (empty), `max_image_resolution` `0.5`.

### Example Output
The output chunks joined into one text:

````text
# Image Description

This illustration features three simple, minimalist icons on a warm terracotta/salmon-colored background:

1. **Top Left - Molecular Structure**: A white icon depicting a connected network of circles (atoms) linked by lines (bonds), resembling a chemical molecule or organic compound structure.

2. **Right Side - Curved Snake/Wave**: A black, flowing curved line that resembles either a snake in motion or an abstract wavy line, positioned vertically along the right portion of the image.

3. **Bottom Left - Hand Gesture**: A black line drawing of an open hand with fingers extended, appearing to gesture or present something.

The overall design has a clean, modern aesthetic with strong contrast between the white and black icons against the warm background color. The style suggests this could be related to science, biology, chemistry, health, or wellness concepts.
````

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes | none |  | Input prompt |
| `system_prompt` | string | No | `""` |  | System prompt |
| `image` | string (URL) | No | none |  | Optional input image URL. An image counts as (width px x height px) / 750 input tokens. |
| `max_image_resolution` | number | No | `0.5` | `0.001` to `2` | Maximum image resolution in megapixels. The image is scaled down to this size before it reaches the model, which lowers its input token count. |
| `max_tokens` | integer | No | `8192` | `1024` to `64000` | Maximum number of output tokens |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.001 per API unit.
- **1 API unit = 100 weighted tokens**; an output token counts 1, an input token counts 0.2.
- That is **$2 per million input tokens** and **$10 per million output tokens**.
- Each request rounds up to a whole unit.
- Input tokens include the prompt, the system prompt and the image. An image counts as (width px x height px) / 750 tokens after it is scaled to `max_image_resolution`.
- **Example cost**: the example request used 663 input tokens and 187 output tokens: 663 x 0.2 + 187 = 319.6 weighted tokens, rounded up to 4 units, so it cost **$0.004**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/coding-performance-ai-anthropic-claude-4-5-haiku`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/coding-performance-ai-anthropic-claude-4-5-haiku/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "anthropic/claude-4.5-haiku",
    "input": {
      "image": "https://blog.api.market/wp-content/uploads/2026/10/claude-4-5-haiku-input-api-market.png",
      "prompt": "Describe the image in detail",
      "max_tokens": 1024,
      "system_prompt": "",
      "max_image_resolution": 0.5
    }
  }'
```

Response (201 Created):
```json
{
  "id": "v250kfx7asrmw0d1c6qa84hh2w",
  "version": "anthropic/claude-4.5-haiku",
  "status": "starting",
  "created_at": "2026-10-22T03:36:38.658Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/coding-performance-ai-anthropic-claude-4-5-haiku/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "v250kfx7asrmw0d1c6qa84hh2w",
  "status": "succeeded",
  "output": [
    "# Image Description\n\nThis illustration features three simple, minimalist icons on a warm terracotta/salmon-colored background:\n\n1. **Top Left - Molecular Structure**: A white icon depicting a connected network of circles (atoms) linked by lines (bonds), resembling a chemical molecule or organic compound structure.\n\n2. **Right Side - Curved Snake/Wave**: A black, flowing curved line that resembles either a snake in motion or an abstract wavy line, positioned vertically along the right portion of the image.\n\n3. **Bottom Left - Hand Gesture**: A black line drawing of an open hand with fingers extended, appearing to gesture or present something.\n\nThe overall design has a clean, modern aesthetic with strong contrast between the white and black icons against the warm background color. The style suggests this could be related to science, biology, chemistry, health, or wellness concepts."
  ],
  "error": null,
  "created_at": "2026-10-22T03:36:38.658Z",
  "started_at": "2026-10-22T03:36:39.158Z",
  "completed_at": "2026-10-22T03:36:42.799Z"
}
```

`output` is an array of text chunks. Join them in order to get the full response. The example above shows the joined text as one chunk for readability.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or a `max_tokens` value below 1024.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/coding-performance-ai-anthropic-claude-4-5-haiku";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "anthropic/claude-4.5-haiku", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output.join("");
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
    "image": "https://blog.api.market/wp-content/uploads/2026/10/claude-4-5-haiku-input-api-market.png",
    "prompt": "Describe the image in detail",
    "max_tokens": 1024,
    "system_prompt": "",
    "max_image_resolution": 0.5
  }).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/coding-performance-ai-anthropic-claude-4-5-haiku"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "anthropic/claude-4.5-haiku", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return "".join(prediction["output"])

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


print(create_and_wait_for_prediction({
    "image": "https://blog.api.market/wp-content/uploads/2026/10/claude-4-5-haiku-input-api-market.png",
    "prompt": "Describe the image in detail",
    "max_tokens": 1024,
    "system_prompt": "",
    "max_image_resolution": 0.5
}))
```

## FAQ
- **How do I get the full answer?**
  - Join the strings in the `output` array in order, for example `output.join("")` in JavaScript or `"".join(output)` in Python.
- **How are images billed?**
  - As input tokens: (width px x height px) / 750 after scaling. Lower `max_image_resolution` to use fewer tokens.
- **Can I send more than one image?**
  - No. The `image` field takes a single image URL per request.
- **What is the longest answer I can get?**
  - Up to 64000 output tokens. Set `max_tokens` between 1024 and 64000; the default is 8192.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page. You can also email our support team at hello@magicapi.com.


Send a prompt and an optional image to Anthropic's Claude Haiku 4.5 and get a fast text answer, with a system prompt and token limit. Pay per token.