Name: GPT-5.4 API: OpenAI Reasoning and Coding Model
Brand: magicapi
SKU: api-magicapi-multi-step-reasoning-coding-api-openai-gpt-5-4
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧠 Reasoning and Coding Chat API (OpenAI GPT-5.4)

## Overview
GPT-5.4 is a model from OpenAI. Its developer describes it as its most capable frontier model for complex professional work, coding and multi-step reasoning.

Send a `prompt` with an optional `system_prompt`, or a full `messages` list for multi-turn chat, and add images in `image_input` if needed. `reasoning_effort` (from `none` to `xhigh`) sets how much the model reasons before answering, and `verbosity` (`low`, `medium`, `high`) sets how long the answer is. The response `output` is a list of text chunks; join them to get the full answer.

## Features
- **Adjustable reasoning**: `reasoning_effort` `none` (default, fast responses), `low`, `medium`, `high` or `xhigh`. Higher efforts give more thorough answers but use more tokens and take longer.
- **Answer length**: `verbosity` `low`, `medium` (default) or `high`.
- **Prompt or chat**: a single `prompt` with `system_prompt`, or a `messages` list. When `messages` is set, `prompt` and `system_prompt` are ignored.
- **Image input**: pass image URLs in `image_input` and ask about them.
- **Token cap**: `max_completion_tokens` limits output tokens, including tokens spent on reasoning.

## Use Cases
1. **Code generation**: complete programs, refactors and code reviews, like the Go program in the example.
2. **Analysis and planning**: multi-step problems where higher `reasoning_effort` pays off.
3. **Document and image questions**: answers about screenshots, charts or photos sent in `image_input`.
4. **Agents and assistants**: multi-turn chat built on the `messages` list.

## Visual Examples
### Example Input
A coding request with `reasoning_effort` set to `high`:

```json
{
  "prompt": "Write a simulation of The Odyssey by Homer in Go",
  "messages": [],
  "verbosity": "medium",
  "image_input": [],
  "reasoning_effort": "high"
}
```

### Example Output
The output chunks joined into one text. The full response is a 411-line answer with a complete Go program; the start and the end are shown here:

````text
Here’s a self-contained Go program that simulates Odysseus’s journey home as a narrative/stat-based adventure.

```go
package main

import (
	"flag"
	"fmt"
	"math/rand"
	"strings"
	"time"
)

type State struct {
	rng *rand.Rand

	day int

	crew  int
	ships int

	originCrew  int
	originShips int

	supplies int
	morale   int

	athenaFavor  int
	poseidonWrath int

	cunning  int
	strength int

	prophecyHeard bool
	atIthaca      bool
	restored      bool

	suitors int
}


[... middle of the program omitted ...]

	fmt.Println()

	for i, ep := range episodes {
		fmt.Println(strings.Repeat("-", 72))
		fmt.Printf("%2d. %s\n", i+1, ep.Name)
		fmt.Println(strings.Repeat("-", 72))

		ep.Run(state)
		state.normalize()
		state.snapshot()
		fmt.Println()
	}

	summary(state)
}
```

### Run it

```bash
go run main.go
```

Or with a fixed seed for repeatable results:

```bash
go run main.go -seed 42
```

### What this does
- Simulates the major episodes of *The Odyssey*
- Tracks:
  - crew
  - ships
  - supplies
  - morale
  - Athena’s favor
  - Poseidon’s wrath
- Adds a little randomness while keeping the overall Homeric arc intact

If you want, I can also turn this into:
1. a **playable text adventure**,
2. a **turn-based strategy sim**,
3. or a **more faithful book-by-book simulation**.
````

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | No | none |  | The prompt to send to the model. Do not use if using messages. |
| `system_prompt` | string | No | none |  | System prompt to set the assistant's behavior |
| `messages` | array of objects | No | `[]` |  | A list of chat messages, for example: [{"role": "user", "content": "Hello, how are you?"}]. If provided, prompt and system_prompt are ignored. |
| `image_input` | array of URLs | No | `[]` |  | List of images to send to the model |
| `reasoning_effort` | string | No | `none` | `none`, `low`, `medium`, `high`, `xhigh` | Constrains effort on reasoning. Supported values are none, low, medium, high and xhigh. The default none gives fast, low-latency responses. Higher reasoning efforts produce more thorough answers but use more tokens and take longer. For higher reasoning efforts you may need to increase max_completion_tokens to avoid empty responses (where all the tokens are used on reasoning). |
| `verbosity` | string | No | `medium` | `low`, `medium`, `high` | Constrains the verbosity of the response. Lower values give more concise responses, higher values give more detailed responses. Supported values are low, medium and high. |
| `max_completion_tokens` | integer | No | none |  | Maximum number of completion tokens to generate. For higher reasoning efforts you may need to increase it to avoid empty responses (where all the tokens are used on reasoning). |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0019 per API unit.
- **1 API unit = 100 weighted tokens; an output token counts 1, an input token counts 0.1667.**
- That is **$3.1673 per million input tokens** and **$19 per million output tokens**.
- Output tokens include the tokens the model spends on reasoning, so a higher `reasoning_effort` costs more. Each request is rounded up to a whole unit.
- **Example cost**: the example request (`reasoning_effort` `high`) used 16 input tokens and 12,655 output tokens: 16 x 0.1667 + 12,655 = 12,657.67 weighted tokens, rounded up to 127 units = **$0.2413**.
- **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/multi-step-reasoning-coding-api-openai-gpt-5-4`

### 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 2 seconds and an overall timeout of 900 seconds (15 minutes) work well. Reasoning requests can run for several minutes; the example took about 159 seconds.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/multi-step-reasoning-coding-api-openai-gpt-5-4/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "openai/gpt-5.4",
    "input": {
      "prompt": "Write a simulation of The Odyssey by Homer in Go",
      "messages": [],
      "verbosity": "medium",
      "image_input": [],
      "reasoning_effort": "high"
    }
  }'
```

Response (201 Created):
```json
{
  "id": "kj0ykv1sqdrmy0d1c6t9c3e89w",
  "version": "openai/gpt-5.4",
  "status": "starting",
  "created_at": "2026-10-22T03:42:43.819Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/multi-step-reasoning-coding-api-openai-gpt-5-4/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "kj0ykv1sqdrmy0d1c6t9c3e89w",
  "status": "succeeded",
  "output": [
    "Here",
    "’s",
    " a",
    " self",
    "-contained",
    " Go",
    " program",
    " that",
    " sim",
    "ulates",
    " Od",
    "ys"
  ],
  "error": null,
  "created_at": "2026-10-22T03:42:43.819Z",
  "started_at": "2026-10-22T03:42:44.019Z",
  "completed_at": "2026-10-22T03:45:22.681Z"
}
```

`output` is a list of text chunks (abridged above; the example response has 3297 chunks). Join them in order to get the full response text.

### 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 `reasoning_effort` or `verbosity` value 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/multi-step-reasoning-coding-api-openai-gpt-5-4";

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: "openai/gpt-5.4", 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 = 900000;
  const pollInterval = 2000;
  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 15 minutes");
}

createAndWaitForPrediction({
    "prompt": "Write a simulation of The Odyssey by Homer in Go",
    "messages": [],
    "verbosity": "medium",
    "image_input": [],
    "reasoning_effort": "high"
  }).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/multi-step-reasoning-coding-api-openai-gpt-5-4"


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": "openai/gpt-5.4", "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 = 900
    poll_interval = 2
    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 15 minutes")


print("".join(create_and_wait_for_prediction({
    "prompt": "Write a simulation of The Odyssey by Homer in Go",
    "messages": [],
    "verbosity": "medium",
    "image_input": [],
    "reasoning_effort": "high"
})))
```

## FAQ
- **How do I get the full answer from `output`?**
  - `output` is a list of text chunks. Join them in order, for example `output.join("")` in JavaScript or `"".join(output)` in Python.
- **Which `reasoning_effort` should I use?**
  - `none` (the default) is fastest and cheapest. Use `medium`, `high` or `xhigh` for hard coding and multi-step problems; they use more output tokens and take longer.
- **Why did I get an empty response?**
  - With a high `reasoning_effort` and a low `max_completion_tokens`, all tokens can be used on reasoning. Raise `max_completion_tokens` or leave it unset.
- **How much does a request cost?**
  - $3.1673 per million input tokens and $19 per million output tokens (reasoning included), rounded up to a whole unit of $0.0019. The example request cost $0.2413.
- **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.


Use OpenAI GPT-5.4 for coding, analysis and multi-step reasoning with text and image input, reasoning effort and verbosity controls.