Name: Claude Sonnet 5 API: Code and Text Generation
Brand: magicapi
SKU: api-magicapi-code-generation-ai-anthropic-claude-sonnet-5
Availability: InStock
Author: API Market

Shashank Agarwal

# 💻 Code and Text Generation API (Anthropic Claude Sonnet 5)

## Overview
Claude Sonnet 5 is a large language model from Anthropic. Its developer describes it as its most agentic Sonnet model, bringing frontier-level coding and tool use at Sonnet's speed and price.

This API takes a text `prompt`, an optional `system_prompt` and one optional `image`, and returns the model's text answer. You choose how much the model thinks before answering with `effort`, and cap the answer length with `max_tokens`. Tool definitions and multi-turn message lists are not part of the input: put any context the model needs into `prompt` or `system_prompt`.

## Features
- **Text and code answers**: send a `prompt` and get a written answer, code, or a step-by-step explanation.
- **System prompt**: set the model's role, tone or rules with `system_prompt` (default empty).
- **Thinking effort**: `effort` is `low` (default), `medium`, `high`, `xhigh` or `max`. `low` disables thinking for the fastest, cheapest answers; higher levels improve quality on hard coding and agentic tasks but are slower and use more output tokens.
- **Image input**: pass one image URL as `image`. It is scaled down to at most `max_image_resolution` megapixels (default 0.5, range 0.001 to 2) before the model sees it.
- **Answer length**: `max_tokens` sets the maximum number of output tokens, from 1024 to 64000 (default 8192).
- **Chunked output**: the answer is returned as a list of text chunks that you join in order.

## Use Cases
1. **Writing and reviewing code**: generate functions, explain a bug, or refactor a snippet pasted into `prompt`.
2. **Math and technical reasoning**: check a derivation or work through a proof step by step, as in the example below.
3. **Questions about an image**: send a screenshot, chart or diagram as `image` and ask about it in `prompt`.
4. **Technical writing**: draft documentation, summaries or specifications with a `system_prompt` that sets the style.

## Examples
### Example Input
```json
{
  "effort": "low",
  "prompt": "Show that this disproves the jacobian conjecture: ((1+xy)^3 z + y^2 (1+xy) (4+3xy), y + 3 x (1+xy)^2  z + 3 x y^2 (4+3xy), 2 x - 3 x^2 y - x^3 z): \\C^3\\to \\C^3, has jacobian determinant -2, and sends (0, 0, -1/4), (1, -3/2, 13/2), and (-1, 3/2, 13/2) to (-1/4, 0, 0)",
  "max_tokens": 1024,
  "system_prompt": "",
  "max_image_resolution": 0.5
}
```

`effort` is `low` (thinking disabled) and `max_tokens` is 1024, the smallest allowed value. No image was sent.

### Example Output
The joined output text. The answer stops mid-line because it reached the 1024-token `max_tokens` limit:

```markdown
# Disproving the Jacobian Conjecture in Dimension 3

The **Jacobian Conjecture** states: if $F:\mathbb{C}^n \to \mathbb{C}^n$ is a polynomial map with constant nonzero Jacobian determinant, then $F$ is a bijection (in fact a polynomial automorphism).

This counterexample in $n=3$ - due to Pinchuk-style phenomena, here using the specific map you've given - satisfies the hypothesis but **fails injectivity**, which would disprove the conjecture (if the conjecture were otherwise expected to hold in dimension $\geq 3$... but it is still *open*, so such a counterexample, if genuine, would be a major result). Let's carefully verify the claimed facts.

## The Map

$$F(x,y,z) = \Big((1+xy)^3 z + y^2(1+xy)(4+3xy),\; y + 3x(1+xy)^2 z + 3xy^2(4+3xy),\; 2x - 3x^2y - x^3 z\Big)$$

## Step 1: Verify the Jacobian Determinant

Let $u = 1+xy$. Write:
$$F_1 = u^3 z + y^2 u(4+3xy), \quad F_2 = y + 3xu^2 z + 3xy^2(4+3xy), \quad F_3 = 2x - 3x^2 y - x^3 z$$

Computing partial derivatives (using $u_x = y$, $u_y = x$) and assembling the Jacobian matrix, direct computation (straightforward but tedious symbolic algebra) gives:

$$\det J_F = -2$$

This is a **constant**, confirming the hypothesis of the Jacobian Conjecture is satisfied.

## Step 2: Verify the Three Points Map to the Same Image

**Point $P_1 = (0, 0, -1/4)$:**
- $u = 1+xy = 1$
- $F_1 = 1^3 \cdot(-1/4) + 0 = -1/4$
- $F_2 = 0 + 0 + 0 = 0$
- $F_3 = 0 - 0 - 0 = 0$

$$F(P_1) = (-1/4, 0, 0) \checkmark$$

**Point $P_2 = (1, -3/2, 13/2)$:**
- $xy = -3/2$, so $u = 1 + xy = -1/2$
- $4+3xy = 4 - 9/2 = -1/2$
- $y^2 = 9/4$

$F_1$: $u^3 z + y^2 u(4+3xy) = (-1/2)^3(13/2) + (9/4)(-1/2)(-1/2)$
$$= -\frac{13}{16} + \frac{9}{16} = -\frac{4}{16} = -\frac{1}{4}$$

$F_2$: $y + 3x u^2 z + 3xy^2(4+3xy) = -3/2 + 3(1)(1/4)(13/2) + 3(1)(9/4)
```

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Input prompt |
| `image` | string (URL) | No | none |  | Optional input image URL. Images are priced as (width px * height px) / 750 input tokens |
| `system_prompt` | string | No | `""` |  | System prompt |
| `max_tokens` | integer | No | `8192` | 1024 to 64000 | Maximum number of output tokens |
| `effort` | string | No | `low` | `low`, `medium`, `high`, `xhigh`, `max` | How much thinking the model does before responding. Higher effort improves quality on hard coding and agentic tasks, but is slower and uses more output tokens. `low` disables thinking for the fastest, cheapest responses |
| `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 is sent to the model, which saves time and input tokens |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0013 per API unit.
- **1 API unit = 100 weighted tokens.** An output token counts 1, an input token counts 0.2.
- That works out to **$2.60 per million input tokens** and **$13.00 per million output tokens**.
- Each request is rounded up to a whole API unit, so the smallest charge for a request is $0.0013.
- **Example cost**: the request below used 181 input tokens and 1,024 output tokens: 181 x 0.2 + 1,024 = 1,060.2 weighted tokens, rounded up to 11 API units = **$0.0143**.
- An `image` counts as (width px x height px) / 750 input tokens after it is scaled to `max_image_resolution`. At the default 0.5 megapixels that is about 667 input tokens, roughly $0.0017.
- Higher `effort` levels use more output tokens, so they cost more per request.
- **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/code-generation-ai-anthropic-claude-sonnet-5`

### 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/code-generation-ai-anthropic-claude-sonnet-5/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "anthropic/claude-sonnet-5",
    "input": {
      "effort": "low",
      "prompt": "Show that this disproves the jacobian conjecture: ((1+xy)^3 z + y^2 (1+xy) (4+3xy), y + 3 x (1+xy)^2  z + 3 x y^2 (4+3xy), 2 x - 3 x^2 y - x^3 z): \\C^3\\to \\C^3, has jacobian determinant -2, and sends (0, 0, -1/4), (1, -3/2, 13/2), and (-1, 3/2, 13/2) to (-1/4, 0, 0)",
      "max_tokens": 1024,
      "system_prompt": "",
      "max_image_resolution": 0.5
    }
  }'
```

Response (201 Created):
```json
{
  "id": "3b05xfx795rmt0d1c6q8x6fayr",
  "version": "anthropic/claude-sonnet-5",
  "status": "starting",
  "created_at": "2026-10-22T03:36:38.650Z"
}
```

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

Response when the prediction has finished (200 OK):
```json
{
  "id": "3b05xfx795rmt0d1c6q8x6fayr",
  "status": "succeeded",
  "output": ["#", " Dis", "proving the Jacobian", " Conjecture in", " Dimension 3\n\nThe", " **Jacobian Con", "jecture** states", ": if $F:\\math", "bb{C}^n \\", "to \\mathbb{C", "}^n$ is a pol", "ynomial map with constant n", "onzero Jacobian", " determinant, then $F$", " is a bijection (", "in f", "act a polynomial automor", "phism).\n\nThis coun", "terexample in $n", "=3$ - due", " to", " Pin", "ch", "uk-", "style ph", "enomena, here", " using the specific map you", "'ve", " given - sat", "isfies the h", "ypothesis but **", "fails inj", "ectivity**, which would", " disprove the conjecture", " (if", " the", " conjecture were ot", "herwise exp", "ected to hold in dimension", " $", "\\geq 3$...", " but it is still", " *open*, so", " such", " a counterexample, if gen", "uine, would be a major result", "). Let's carefully ver", "ify the cla", "imed facts.\n\n## The", " Map\n\n$$F(x", ",y,z) = \\", "Big((", "1+xy)^3 ", "z + y^2(1+", "xy)(4+3x", "y),\\; y + 3", "x(1+xy)^", "2 z + 3xy", "^2(4+3xy", "),\\; 2x - ", "3x^2y - x^", "3 z\\Big)$", "$\n\n## Step 1:", " Verify the Jacob", "ian Determinant", "\n\nLet $u = ", "1+xy$. Write", ":\n$$F_1 ", "= u", "^3 z + y^2", " u(", "4+3xy), \\qu", "ad F_2 = y +", " 3x", "u^2 z + 3", "xy^2(", "4+3xy), \\qu", "ad F_3 = 2", "x - 3x^2 ", "y - x^3 z$", "$\n\nComput", "ing partial derivatives (", "using", " $u_", "x = y", "$, $u_y = x", "$) and ass", "embling the Jacobian", " matrix, dire", "ct computation (", "stra", "ightforward but", " tedious sym", "bolic algebra) g", "ives:\n\n$$\\det J", "_", "F = -2$$\n\nThis", " is a **constant**", ", conf", "irming the hypothesis", " of the Jacobian", " Conjecture is", " satisfied.\n\n##", " Step 2: Verify the", " Three Points Map to the", " Same Image", "\n\n**Point $P", "_1 = (0,", " 0, -1/4)", "$:**\n- $u", " = 1+x", "y = 1$\n- $", "F_1 = ", "1^", "3 ", "\\cdot(", "-1/4) + 0", " = -1/4$", "\n- $F_2 = ", "0 + 0 + ", "0 = 0$\n-", " $F_3 = 0", " - 0 - 0", " = 0$", "\n\n$", "$F(P_1) =", " (-1/4, 0", ", 0) \\checkm", "ark$$\n\n**Point $", "P_2 = (1,", " -3/2, 13/", "2)$:**\n- $", "xy = -", "3/2$, so $u", " = 1 ", "+", " xy = -1/2$", "\n- $4", "+3xy = 4 ", "- 9/2 = -", "1/2$\n- $y", "^2 = ", "9/4$\n\n$F_", "1$: $u^3 ", "z + y^2 u(", "4+3xy) = (", "-1/2)^3(", "13/2) + (9/", "4)(-1/2)", "(-1/2)$", "\n$$= -\\frac{", "13", "}{16} + \\frac", "{9}{16} = -", "\\frac{4}{16", "} = -\\frac{1", "}{4}", "$$\n\n$F_2$", ": $y + 3x", " u^2 z + 3", "xy^2(4+3", "xy)", " = -3/2 + ", "3(1)(1/4", ")(13/2) + ", "3(1)(9/4", ")"],
  "error": null,
  "created_at": "2026-10-22T03:36:38.650Z",
  "started_at": "2026-10-22T03:36:39.150Z",
  "completed_at": "2026-10-22T03:36:48.048Z"
}
```

`output` is a list of text chunks in the order the model produced them. Join them with no separator to get the full response.

### 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`, a `max_tokens` below 1024 or an `effort` that is not in the list.
- **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/code-generation-ai-anthropic-claude-sonnet-5";

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-sonnet-5", 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;
    }

    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({
  "effort": "low",
  "prompt": "Show that this disproves the jacobian conjecture: ((1+xy)^3 z + y^2 (1+xy) (4+3xy), y + 3 x (1+xy)^2  z + 3 x y^2 (4+3xy), 2 x - 3 x^2 y - x^3 z): \\C^3\\to \\C^3, has jacobian determinant -2, and sends (0, 0, -1/4), (1, -3/2, 13/2), and (-1, 3/2, 13/2) to (-1/4, 0, 0)",
  "max_tokens": 1024,
  "system_prompt": "",
  "max_image_resolution": 0.5
}).then((output) => console.log(output.join("")));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/code-generation-ai-anthropic-claude-sonnet-5"

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-sonnet-5", "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 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")

output = create_and_wait_for_prediction({
    "effort": "low",
    "prompt": "Show that this disproves the jacobian conjecture: ((1+xy)^3 z + y^2 (1+xy) (4+3xy), y + 3 x (1+xy)^2  z + 3 x y^2 (4+3xy), 2 x - 3 x^2 y - x^3 z): \\C^3\\to \\C^3, has jacobian determinant -2, and sends (0, 0, -1/4), (1, -3/2, 13/2), and (-1, 3/2, 13/2) to (-1/4, 0, 0)",
    "max_tokens": 1024,
    "system_prompt": "",
    "max_image_resolution": 0.5
})
print("".join(output))
```

## FAQ
- **How do I get the full answer as one string?**
  - `output` is a list of text chunks. Join them in order with no separator: `output.join("")` in JavaScript or `"".join(output)` in Python.
- **Why did my answer stop in the middle of a sentence?**
  - The model reached `max_tokens`. The example used 1024, the minimum. Raise `max_tokens` (up to 64000) for long answers; you pay only for the tokens actually generated.
- **Which `effort` should I use?**
  - `low` (the default) disables thinking and is the fastest and cheapest. Use `medium` or higher for hard coding or multi-step problems; these use more output tokens.
- **How much does an image add to the cost?**
  - An image counts as (width px x height px) / 750 input tokens after scaling to `max_image_resolution`. At the default 0.5 megapixels that is about 667 input tokens. Lower `max_image_resolution` to reduce it.
- **Can I send a conversation history or tool definitions?**
  - No. The input is a single `prompt` with an optional `system_prompt` and `image`. Include earlier turns in `prompt` if the model needs them.
- **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.


Call Anthropic's Claude Sonnet 5 for coding, reasoning and image-aware text answers with selectable thinking effort. Pay as you go, no monthly fee.