Name: Gemini 3.5 Flash API: Fast Multimodal Text Generation
Brand: magicapi
SKU: api-magicapi-fast-multimodal-reasoning-api-google-gemini-3-5-flash
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧠 Multimodal Text Generation API (Google Gemini 3.5 Flash)

## Overview
Gemini 3.5 Flash is a multimodal language model from Google. Its developer describes it as a fast model with frontier reasoning across agents, coding and long-context tasks.

Send a text `prompt` and, optionally, up to 10 `images`, up to 10 `videos` and one `audio` file. The model returns text as a list of chunks; join them in order to get the full response.

## Features
- **Text generation**: answers, code and long-form text from a `prompt`, guided by an optional `system_instruction`.
- **Images**: up to 10 image URLs per request, each up to 7MB.
- **Videos**: up to 10 video URLs per request, each up to 45 minutes. `video_fps` (0.1 to 60) sets how many frames per second are sampled; the default is 1 fps.
- **Audio**: one audio file of up to 8.4 hours.
- **Thinking**: `thinking_level` `none` (default), `low` or `high`.
- **Sampling controls**: `temperature` (0 to 2, default 1), `top_p` (0 to 1, default 0.95) and `max_output_tokens` (1 to 65535, default 65535).

## Use Cases
1. **Coding**: write and explain code from a description.
2. **Video and audio questions**: summarize a recording, find a moment in a video or answer questions about spoken content.
3. **Image analysis**: compare several images or extract details from screenshots and photos.
4. **Long documents and chats**: answer questions over long text pasted into the prompt.

## Visual Examples
### Example Input
Prompt: "Write assembly code to describe moving a file from one folder to another"

Other fields: `images` `[]`, `videos` `[]`, `thinking_level` `none`, `temperature` `1`, `top_p` `0.95`, `max_output_tokens` `2048`.

### Example Output
The output chunks joined into one text (shortened here; the full answer continues with an explanation of the code):

````text
Because Assembly language interacts directly with the operating system kernel, file operations depend heavily on the **Operating System (OS)** and **CPU Architecture**.

Below is a complete, working example written in **x86_64 Linux Assembly (NASM syntax)**. In Linux, moving a file between folders is accomplished using the `sys_rename` system call (which changes the file's path).

---

### Linux x86_64 Assembly Code (NASM)

```nasm
section .data
    ; Define the source path and destination path (must be null-terminated with 0)
    old_path db "/tmp/source_folder/myfile.txt", 0
    new_path db "/tmp/dest_folder/myfile.txt", 0

    ; Messages for output
    success_msg db "File moved successfully!", 10
    success_len equ $ - success_msg

    error_msg   db "Error: Failed to move file.", 10
    error_len   equ $ - error_msg

section .text
    global _start

_start:
    ; -------------------------------------------------------------
    ; System Call: sys_rename (Syscall #82)
    ; Purpose: Moves/renames a file from old_path to new_path
    ; -------------------------------------------------------------
    mov rax, 82          ; Syscall number 82 = sys_rename
    mov rdi, old_path    ; Argument 1: pointer to original path
    mov rsi, new_path    ; Argument 2: pointer to new path
    syscall              ; Call the Linux kernel

    ; Check return value in RAX
    ; RAX = 0 on success
    ; RAX < 0 on error (contains negative error code)
    cmp rax, 0
    jl  handle_error     ; Jump if Less than 0 (error occurred)

    ; -------------------------------------------------------------
    ; Print Success Message
    ; -------------------------------------------------------------
    mov rax, 1          ; Syscall number 1 = sys_write
    mov rdi, 1          ; File Descriptor 1 = stdout
    mov rsi, success_msg; Address of message
    mov rdx, success_len; Length of message
    syscall
    jmp exit_program

handle_error:
    ; -------------------------------------------------------------
    ; Print Error Message
    ; -------------------------------------------------------------
    mov rax, 1          ; Syscall number 1 = sys_write
    mov rdi, 2          ; File Descriptor 2 = stderr
    mov rsi, error_msg  ; Address of error message
    mov rdx, error_len  ; Length of error message
    syscall

exit_program:
    ; -------------------------------------------------------------
    ; Exit Program
    ; -------------------------------------------------------------
    mov rax, 60         ; Syscall number 60 = sys_exit
    mov rdi, 0          ; Exit code 0
    syscall
```

[...]
````

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes | none |  | The text prompt to send to the model |
| `images` | array of strings (URLs) | No | `[]` |  | Input images to send with the prompt (max 10 images, each up to 7MB) |
| `videos` | array of strings (URLs) | No | `[]` |  | Input videos 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 to sample input videos. Higher values give the model more frames to reason over (useful for fast-moving footage) but consume more tokens. Omit to use the default sampling rate (1 fps). |
| `audio` | string (URL) | No | none |  | Input audio 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.0012 per API unit.
- **1 API unit = 100 weighted tokens**; an output token counts 1, an input token counts 0.1667.
- That is **$2.0004 per million input tokens** and **$12 per million output tokens**.
- Each request rounds up to a whole unit.
- Input tokens include the prompt, the system instruction and any images, videos and audio. A higher `video_fps` samples more frames and uses more tokens.
- **Example cost**: the example request used 13 input tokens and 813 output tokens: 13 x 0.1667 + 813 = 815.1671 weighted tokens, rounded up to 9 units, so it cost **$0.0108**.
- **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/fast-multimodal-reasoning-api-google-gemini-3-5-flash`

### 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/fast-multimodal-reasoning-api-google-gemini-3-5-flash/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "google/gemini-3.5-flash",
    "input": {
      "top_p": 0.95,
      "images": [],
      "prompt": "Write assembly code to describe moving a file from one folder to another",
      "videos": [],
      "temperature": 1,
      "thinking_level": "none",
      "max_output_tokens": 2048
    }
  }'
```

Response (201 Created):
```json
{
  "id": "0m32wwkfmnrmy0d1c6sahz0c40",
  "version": "google/gemini-3.5-flash",
  "status": "starting",
  "created_at": "2026-10-22T03:40:46.541Z"
}
```

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

Response when the prediction has finished (200 OK):
```json
{
  "id": "0m32wwkfmnrmy0d1c6sahz0c40",
  "status": "succeeded",
  "output": [
    "Because Assembly language interacts directly with the operating system kernel, file operations depend heavily on the **Operating System (OS)** and **CPU Architecture**.\n\nBelow is a complete, working example written in **x86_64 Linux Assembly (NASM syntax)**. In Linux, moving a file between folders is accomplished using the `sys_rename` system call (which changes the file's path).\n\n---\n\n### Linux x86_64 Assembly Code (NASM)\n\n```nasm\nsection .data\n    ; Define the source path and destination path (must be null-terminated with 0)\n    old_path db \"/tmp/source_folder/myfile.txt\", 0\n    new_path db \"/tmp/dest_folder/myfile.txt\", 0\n\n    ; Messages for output\n    success_msg db \"File moved successfully!\", 10\n    success_len equ $ - success_msg\n\n    error_msg   db \"Error: Failed to move file.\", 10\n    error_len   equ $ - error_msg\n\nsection .text\n    global _start\n\n_start:\n    ; -------------------------------------------------------------\n    ; System Call: sys_rename (Syscall #82)\n    ; Purpose: Moves/renames a file from old_path to new_path\n    ; -------------------------------------------------------------\n    mov rax, 82          ; Syscall number 82 = sys_rename\n    mov rdi, old_path    ; Argument 1: pointer to original path\n    mov rsi, new_path    ; Argument 2: pointer to new path\n    syscall              ; Call the Linux kernel\n\n    ; Check return value in RAX\n    ; RAX = 0 on success\n    ; RAX < 0 on error (contains negative error code)\n    cmp rax, 0\n    jl  handle_error     ; Jump if Less than 0 (error occurred)\n\n    ; -------------------------------------------------------------\n    ; Print Success Message\n    ; -------------------------------------------------------------\n    mov rax, 1          ; Syscall number 1 = sys_write\n    mov rdi, 1          ; File Descriptor 1 = stdout\n    mov rsi, success_msg; Address of message\n    mov rdx, success_len; Length of message\n    syscall\n    jmp exit_program\n\nhandle_error:\n    ; -------------------------------------------------------------\n    ; Print Error Message\n    ; -------------------------------------------------------------\n    mov rax, 1          ; Syscall number 1 = sys_write\n    mov rdi, 2          ; File Descriptor 2 = stderr\n    mov rsi, error_msg  ; Address of error message\n    mov rdx, error_len  ; Length of error message\n    syscall\n\nexit_program:\n    ; -------------------------------------------------------------\n    ; Exit Program\n    ; -------------------------------------------------------------\n    mov rax, 60         ; Syscall number 60 = sys_exit\n    mov rdi, 0          ; Exit code 0\n    syscall\n```\n\n[...]"
  ],
  "error": null,
  "created_at": "2026-10-22T03:40:46.541Z",
  "started_at": "2026-10-22T03:40:47.041Z",
  "completed_at": "2026-10-22T03:40:58.049Z"
}
```

`output` is an array of text chunks. Join them in order to get the full response. The example above shows the shortened 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 `temperature` above 2.
- **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/fast-multimodal-reasoning-api-google-gemini-3-5-flash";

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.5-flash", 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({
    "top_p": 0.95,
    "images": [],
    "prompt": "Write assembly code to describe moving a file from one folder to another",
    "videos": [],
    "temperature": 1,
    "thinking_level": "none",
    "max_output_tokens": 2048
  }).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/fast-multimodal-reasoning-api-google-gemini-3-5-flash"


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.5-flash", "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({
    "top_p": 0.95,
    "images": [],
    "prompt": "Write assembly code to describe moving a file from one folder to another",
    "videos": [],
    "temperature": 1,
    "thinking_level": "none",
    "max_output_tokens": 2048
}))
```

## 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.
- **What media can I send?**
  - Up to 10 images (each up to 7MB), up to 10 videos (each up to 45 minutes) and one audio file (up to 8.4 hours), as URLs.
- **How do I control video cost?**
  - Video frames count as input tokens. Lower `video_fps` to sample fewer frames; omit it to use the default of 1 frame per second.
- **How do I turn on reasoning?**
  - Set `thinking_level` to `low` or `high`. The default `none` answers without a thinking step.
- **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 text, images, videos and audio to Google's Gemini 3.5 Flash and get text back. Pay as you go, no monthly fee.