Name: Gemini 3 Pro API: Multimodal Reasoning LLM
Brand: magicapi
SKU: api-magicapi-advanced-reasoning-api-google-gemini-3-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧠 Multimodal Reasoning LLM API (Google Gemini 3 Pro)

## Overview
Gemini 3 Pro is a large language model from Google. Google describes it as its most advanced reasoning Gemini model.

Send a text `prompt` and, optionally, up to 10 `images`, up to 10 `videos` and one `audio` file. Set how much the model reasons with `thinking_level` (`none`, `low` or `high`). The answer comes back as a list of text chunks; join them in order to get the full text.

## Features
- **Thinking levels**: `thinking_level` is `none` (default), `low` or `high` and sets how much the model reasons before it answers.
- **Image input**: up to 10 image URLs in `images`, each up to 7MB.
- **Video input**: up to 10 video URLs in `videos`, each up to 45 minutes. `video_fps` (0.1 to 60) sets how many frames per second are sampled; leave it out for the default of 1 fps. More frames give the model more to reason over and use more tokens.
- **Audio input**: one audio file of up to 8.4 hours in `audio`.
- **System instruction**: steer the role, tone or format of the answer with `system_instruction`.
- **Long answers**: `max_output_tokens` goes up to 65535, which is also the default.
- **Sampling controls**: `temperature` (0 to 2, default 1) and `top_p` (0 to 1, default 0.95).

## Use Cases
1. **Multi-step reasoning**: planning, math and analysis tasks where `high` thinking helps.
2. **Code generation and review**: ask for code, or paste code into the prompt and ask for an explanation or a fix.
3. **Audio and video understanding**: summarize a recording or answer questions about a meeting, lecture or clip.
4. **Questions about images**: send screenshots, charts, documents or photos with a question about them.

## Visual Examples
### Example Input
Prompt: "Summarize what the speaker says in three sentences.", with a 60-second audiobook recording in `audio`, `thinking_level` `low` and `max_output_tokens` `2048`.

[Listen to the example audio](https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3)

```json
{
  "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3",
  "top_p": 0.95,
  "images": [],
  "prompt": "Summarize what the speaker says in three sentences.",
  "videos": [],
  "temperature": 1,
  "thinking_level": "low",
  "max_output_tokens": 2048
}
```

### Example Output
The model returned 4 text chunks. Joined, they read:

~~~text
The speaker begins the preface to his memoirs by observing that people rarely have control over the major events in their lives. He explains that despite frequent urging from his friends, he had initially resolved never to write a book or publish his work. However, a severe fall at age sixty-two confined him to his house, which ultimately led him to change his mind and begin writing.
~~~

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | The text prompt to send to the model |
| `images` | array of strings (URLs) | No | `[]` |  | Input image URLs to send with the prompt (max 10 images, each up to 7MB) |
| `videos` | array of strings (URLs) | No | `[]` |  | Input video URLs to send with the prompt (max 10 videos, each up to 45 minutes) |
| `video_fps` | number | No | none | `0.1` to `60` | Frame rate (frames per second) at which input videos are sampled. Higher values give the model more frames to reason over (useful for fast-moving footage) but use more tokens. Leave empty for the default sampling rate of 1 fps. |
| `audio` | string (URL) | No | none |  | Input audio URL to send with the prompt (max 1 audio file, up to 8.4 hours) |
| `system_instruction` | string | No | none |  | System instruction to guide the model's behavior |
| `thinking_level` | string | No | `none` | `none`, `low`, `high` | Thinking level for reasoning: `none`, `low` or `high` |
| `temperature` | number | No | `1` | `0` to `2` | Sampling temperature between 0 and 2 |
| `top_p` | number | No | `0.95` | `0` to `1` | Nucleus sampling: the model considers the tokens within the top_p probability mass |
| `max_output_tokens` | integer | No | `65535` | `1` to `65535` | Maximum number of tokens to generate |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0023 per API unit.
- **1 API unit = 100 weighted tokens**; an output token counts 1, an input token counts 0.2223.
- That is **$5.1129 per million input tokens** and **$23 per million output tokens**.
- Each request is rounded up to a whole API unit, so the minimum charge is 1 unit ($0.0023).
- Attached images, videos and audio are part of the input token count the model reports (the example's short prompt plus 60 seconds of audio counted as 1,510 input tokens).
- **Example cost**: the example request used 1,510 input tokens and 75 output tokens: 1,510 x 0.2223 + 75 = 410.673 weighted tokens, rounded up to 5 API units = **$0.0115**.
- **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/advanced-reasoning-api-google-gemini-3-pro`

### 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/advanced-reasoning-api-google-gemini-3-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
      "version": "google/gemini-3-pro",
      "input": {
        "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3",
        "top_p": 0.95,
        "images": [],
        "prompt": "Summarize what the speaker says in three sentences.",
        "videos": [],
        "temperature": 1,
        "thinking_level": "low",
        "max_output_tokens": 2048
      }
    }'
```

Response (201 Created):
```json
{
  "id": "mksz94t5z1rmt0d1c6wt6b275r",
  "version": "google/gemini-3-pro",
  "status": "starting",
  "created_at": "2026-10-22T03:48:14.645Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/advanced-reasoning-api-google-gemini-3-pro/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "mksz94t5z1rmt0d1c6wt6b275r",
  "status": "succeeded",
  "output": [
    "The speaker begins the preface to his memoirs by observing that people rarely have control",
    " over the major events in their lives. He explains that despite frequent urging from his friends, he had initially resolved never to",
    " write a book or publish his work. However, a severe fall at age sixty-two confined him to his house, which ultimately",
    " led him to change his mind and begin writing."
  ],
  "error": null,
  "created_at": "2026-10-22T03:48:14.645Z",
  "started_at": "2026-10-22T03:48:14.668Z",
  "completed_at": "2026-10-22T03:48:27.015Z"
}
```

`output` is a list of text chunks. Join them in order to get the full answer, shown under Example Output.

### 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 `thinking_level` that is not `none`, `low` or `high`, or more than 10 images.
- **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/advanced-reasoning-api-google-gemini-3-pro";

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: "google/gemini-3-pro", 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({
    "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3",
    "top_p": 0.95,
    "images": [],
    "prompt": "Summarize what the speaker says in three sentences.",
    "videos": [],
    "temperature": 1,
    "thinking_level": "low",
    "max_output_tokens": 2048
  }).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/advanced-reasoning-api-google-gemini-3-pro"


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": "google/gemini-3-pro", "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({
    "audio": "https://blog.api.market/wp-content/uploads/2026/10/scribe-v2-input-api-market.mp3",
    "top_p": 0.95,
    "images": [],
    "prompt": "Summarize what the speaker says in three sentences.",
    "videos": [],
    "temperature": 1,
    "thinking_level": "low",
    "max_output_tokens": 2048
})
print("".join(output))
```

## FAQ
- **How do I get the full answer text?**
  - Join the chunks in `output` in order, for example `output.join("")` in JavaScript or `"".join(output)` in Python.
- **Which thinking level should I use?**
  - `none` is the default. `low` and `high` let the model reason before answering; `high` suits hard multi-step problems and can use more output tokens.
- **Can I send a video or an audio file?**
  - Yes. Pass up to 10 video URLs in `videos` (each up to 45 minutes) and one audio URL in `audio` (up to 8.4 hours). Raise `video_fps` for fast-moving footage; it increases the input token count.
- **How much does a request cost?**
  - Input tokens cost $5.1129 per million and output tokens $23 per million, billed in units of 100 weighted tokens at $0.0023 each and rounded up per request. The example above cost $0.0115.
- **How long can an answer be?**
  - Up to 65535 tokens, set with `max_output_tokens` (the default is also 65535). Lower it to cap the length and the cost of each answer.
- **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`.

## 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 Google Gemini 3 Pro with text, images, video and audio, with optional low or high thinking. Pay as you go, no monthly fee.