Name: DeepSeek V4 Flash API – OpenAI-Compatible LLM
Brand: henry-ai
SKU: api-henry-ai-deepseek-v4-flash
Availability: InStock
Author: API Market

## Overview

DeepSeek V4 Flash 0731 API is an OpenAI-compatible chat completions endpoint served by a private int8 (W8A8) deployment. It accepts up to 512K tokens of context, emits up to 128K tokens per response, and supports streaming, tool calling and reasoning.

Because the request and response shapes match the OpenAI Chat Completions API, most existing SDKs work by changing the base URL and the auth header. There is one model behind the endpoint, so you do not need to pick or manage a model catalogue.

## Features

- **512K token context**: send long documents, transcripts or codebases in a single request.
- **128K token output**: generate long-form responses without chunking the completion.
- **OpenAI-compatible**: standard `messages`, `temperature`, `top_p`, `max_tokens` and `stop` parameters.
- **Streaming**: server-sent events with a `[DONE]` terminator for token-by-token rendering.
- **Tool calling**: pass a `tools` array to let the model request function calls.
- **Reasoning mode**: enable `reasoning` for step-by-step problem solving.
- **No provider account needed**: your API.market key is the only credential.

## Use Cases

- **Long-document analysis**: summarise or answer questions over contracts, filings and research at full length.
- **Code generation and review**: load a large portion of a repository into context.
- **Chat products**: stream assistant replies into a UI with standard SSE handling.
- **Agents and tool use**: drive function calls from natural-language instructions.
- **Batch content generation**: high monthly quotas suit bulk drafting and rewriting.
- **Migration from OpenAI**: point an existing integration at a different backend with minimal code change.

## API Documentation

### Base URL

```
https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash
```

### Authentication

Pass your API.market key in the `x-api-market-key` header on every request. No other credential is needed, and this endpoint does not use an `Authorization: Bearer` header.

```
x-api-market-key: YOUR_API_MARKET_KEY
```

Find your key under **Account → API Keys** on api.market. Requests without this header return `400` with `No x-api-market-key or x-magicapi-key defined in headers`.

### Endpoints

#### POST /v1/chat/completions

Generates a chat completion.

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `messages` | array | Yes | Conversation history, each with `role` and `content` |
| `model` | string | No | `deepseek-v4-flash-0731`. One model is served, so this field is effectively ignored |
| `max_tokens` | integer | No | 1 to 131072 |
| `temperature` | number | No | 0 to 2 |
| `top_p` | number | No | 0 to 1 |
| `stop` | array | No | Up to 16 stop sequences |
| `stream` | boolean | No | Stream the response as server-sent events |
| `tools` | array | No | Function definitions the model may call |
| `reasoning` | boolean | No | Enable step-by-step reasoning |

```bash
curl -X POST "https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash/v1/chat/completions" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash-0731",
    "messages": [{"role": "user", "content": "Explain B-trees in two sentences."}],
    "max_tokens": 200
  }'
```

```json
{
  "id": "chatcmpl-3fc03e87-2f23-4178-96d6-cea62650e3bc",
  "object": "chat.completion",
  "created": 1787514842,
  "model": "deepseek-v4-flash-0731",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "A B-tree is ..." },
      "finish_reason": "stop"
    }
  ]
}
```

**Streaming.** Set `"stream": true` to receive `text/event-stream` chunks. Each chunk arrives as a `data:` line carrying a `chat.completion.chunk` object, and the stream ends with `data: [DONE]`.

```bash
curl -N -X POST "https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash/v1/chat/completions" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Count to five"}],"stream":true}'
```

**Tool calling.** Pass a `tools` array using the standard OpenAI function schema. The model replies with `tool_calls` when it decides a function is needed.

```json
{
  "messages": [{"role": "user", "content": "What is the weather in Paris?"}],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
          "type": "object",
          "properties": { "city": { "type": "string" } },
          "required": ["city"]
        }
      }
    }
  ]
}
```

#### GET /v1/models

Returns metadata for the served model: context and output limits, supported parameters, quantisation, concurrency and compliance flags.

```bash
curl "https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash/v1/models" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

```json
{
  "object": "list",
  "data": [
    {
      "id": "deepseek-v4-flash-0731",
      "name": "DeepSeek V4 Flash 0731",
      "description": "DeepSeek V4 Flash 0731 served by a private W8A8 deployment.",
      "quantization": "int8",
      "input_modalities": [
        { "type": "text", "supported_inputs": { "max_context_length": { "value": 512000, "unit": "token" } } }
      ],
      "output_modalities": [
        { "type": "text", "streaming": true, "max_length": { "value": 131072, "unit": "token" } }
      ],
      "is_ready": true
    }
  ]
}
```

### Using an OpenAI SDK

The response shape is OpenAI-compatible, but authentication is not: API.market expects `x-api-market-key` rather than a bearer token. Configure the key as a default header and pass a placeholder API key.

```python
from openai import OpenAI

client = OpenAI(
    base_url="https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash/v1",
    api_key="unused",
    default_headers={"x-api-market-key": "YOUR_API_MARKET_KEY"},
)

resp = client.chat.completions.create(
    model="deepseek-v4-flash-0731",
    messages=[{"role": "user", "content": "Explain quicksort briefly."}],
    max_tokens=300,
)
print(resp.choices[0].message.content)
```

## Status Codes

| Code | Meaning | What to do |
| --- | --- | --- |
| `200` | Success | Parse the response body |
| `400` | Malformed request body or missing `x-api-market-key` header | Check the JSON payload and headers |
| `401` | Invalid or expired API key | Verify the key under Account → API Keys |
| `403` | Your subscription does not cover this endpoint | Check your active plan |
| `429` | Plan quota exhausted or rate limit exceeded | Back off and retry, or upgrade |
| `5xx` | Upstream inference error | Retry with exponential backoff |

## Rate Limits

Quotas apply per billing period:

- **Free**: 100 API units, hard limit, 1 request per second. Requests are rejected once the quota is spent.
- **Start**: 100,000 API units per month, soft limit with overage billed per additional call, 4 requests per second.
- **Pro**: 1,000,000 API units per month, soft limit with a lower overage rate, 4 requests per second.

Every request costs one unit regardless of token count. The deployment serves up to 64 concurrent requests in total.

## Error Handling

Errors return an OpenAI-style object:

```json
{ "error": { "message": "Invalid API key", "type": "authentication_error" } }
```

Because only one model is served, an unrecognised `model` value does not fail. The request is answered by `deepseek-v4-flash-0731` and the response `model` field reports what actually ran, so read it back if you need certainty.

Long-context requests take longer to process. Set a generous client timeout, or use `stream: true` so the connection produces output immediately instead of waiting for the full completion. Retry `5xx` responses with exponential backoff.

## Implementation Guide

### Example Code

```python
import json
import requests

URL = "https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash/v1/chat/completions"
HEADERS = {"x-api-market-key": "YOUR_API_MARKET_KEY", "Content-Type": "application/json"}

def stream_reply(prompt):
    body = {"messages": [{"role": "user", "content": prompt}],
            "stream": True, "max_tokens": 500}
    with requests.post(URL, headers=HEADERS, json=body, stream=True, timeout=300) as r:
        r.raise_for_status()
        for line in r.iter_lines():
            if not line or not line.startswith(b"data: "):
                continue
            payload = line[6:]
            if payload == b"[DONE]":
                break
            delta = json.loads(payload)["choices"][0].get("delta", {})
            if "content" in delta:
                print(delta["content"], end="", flush=True)

stream_reply("Summarise the CAP theorem.")
```

```javascript
const URL =
  "https://prod.api.market/api/v1/henry-ai/deepseek-v4-flash/v1/chat/completions";

async function complete(messages, opts = {}) {
  const res = await fetch(URL, {
    method: "POST",
    headers: {
      "x-api-market-key": process.env.API_MARKET_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ messages, max_tokens: 500, ...opts }),
  });
  if (!res.ok) throw new Error(`Completion failed: ${res.status}`);
  const data = await res.json();
  return data.choices[0].message.content;
}

console.log(await complete([{ role: "user", content: "Hello" }]));
```

### Performance Optimization

- Stream long responses. Time to first token stays low and users see output while generation continues.
- Set `max_tokens` to what you actually need. Unbounded generation on a 128K output ceiling is the main cause of slow requests.
- Keep prompts tight even though 512K context is available: more context means more prefill time on every call.
- Respect the concurrency ceiling of 64 requests across the deployment, and your plan's per-second limit of 1 on Free or 4 on paid tiers.
- Cache deterministic completions by prompt hash with `temperature: 0` to avoid paying for repeated identical work.

## FAQ

**Do I need a DeepSeek account to use this API?**

No. Your API.market key is the only credential required.

**Can I use the official OpenAI SDK?**

Yes. Point `base_url` at the API.market endpoint and pass your key as an `x-api-market-key` default header rather than as a bearer token.

**Which models are available?**

One: `deepseek-v4-flash-0731`. Call `/v1/models` for its full capability metadata.

**What happens if I send a different model name?**

The request still succeeds and is served by `deepseek-v4-flash-0731`. Check the `model` field in the response to confirm what ran.

**How large is the context window?**

512,000 input tokens, with up to 131,072 tokens per response.

**Is streaming supported?**

Yes. Set `"stream": true` and read `text/event-stream` chunks until `data: [DONE]`.

**Does it support tool calling and reasoning?**

Yes. Pass a standard OpenAI `tools` array, or set `"reasoning": true` for step-by-step problem solving.

**Where is the model hosted?**

The deployment reports a datacentre in China and zero-data-retention compliance. Check `/v1/models` for the current flags.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Access DeepSeek V4 Flash 0731 through a fast OpenAI-compatible API with streaming, reasoning, coding support, and up to 512K-token context.

DeepSeek V4 Flash API – OpenAI-Compatible LLM