Name: DeepSeek API - OpenAI Compatible Chat & Reasoning
Brand: kelewenai
SKU: api-kelewenai-deepseek-api
Availability: InStock
Author: API Market

kelewen

## Overview

DeepSeek API gives you production access to DeepSeek's chat and reasoning models through a standard OpenAI-compatible interface. Point your existing OpenAI client at the API.market base URL, swap in your API.market key, and your code works unchanged — no new SDK, no rewrite.

Two models are available: `deepseek-chat` for fast general-purpose conversation, drafting and coding, and `deepseek-reasoner` for step-by-step analytical work that returns its chain of thought alongside the answer. Both support Server-Sent Events streaming.

Billing, keys and quotas are handled by API.market, so you get one key that works across every API on the platform and a single invoice instead of a separate account with the model provider.

## Features

- **Drop-in OpenAI compatibility** — works with the official OpenAI SDKs, LangChain, LiteLLM, Vercel AI SDK, and any OpenAI-compatible client.
- **Two models, one endpoint** — switch between conversation and reasoning by changing the `model` field.
- **Exposed reasoning** — `deepseek-reasoner` returns a `reasoning_content` field so you can inspect how the answer was reached.
- **Streaming** — full SSE token-by-token streaming, terminated with `data: [DONE]`.
- **Full sampling control** — `temperature`, `top_p`, `max_tokens`, `stop`, `frequency_penalty` and `presence_penalty`.
- **Prompt caching metrics** — every response reports `prompt_cache_hit_tokens` and `prompt_cache_miss_tokens` so you can measure cache effectiveness.
- **Model discovery** — `GET /v1/models` lists what is currently available.

## Use Cases

- **Chat assistants and copilots** — multi-turn conversation with system, user and assistant roles.
- **Math, logic and analysis** — `deepseek-reasoner` for problems where the working matters as much as the answer.
- **Code generation and review** — drafting functions, explaining diffs, writing tests.
- **Content and summarisation** — long-form drafting, rewriting, extraction and summarisation.
- **Cost-sensitive migration** — move an existing OpenAI workload over by changing two lines of configuration.

## API Documentation

### Base URL

```
https://prod.api.market/api/v1/kelewenai/deepseek-api
```

### Authentication

Every request must carry your API.market key in the `x-api-market-key` header. You do not need a DeepSeek account or any provider credential — API.market handles the upstream authentication for you.

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

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

### Endpoints

#### POST /v1/chat/completions

Creates a chat completion.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `model` | string | Yes | `deepseek-chat` or `deepseek-reasoner` |
| `messages` | array | Yes | Conversation history; each item has `role` (`system`, `user`, `assistant`) and `content` |
| `stream` | boolean | No | Stream the response as SSE. Defaults to `false` |
| `max_tokens` | integer | No | Maximum tokens to generate |
| `temperature` | number | No | Sampling temperature, `0`–`2`. Lower is more deterministic |
| `top_p` | number | No | Nucleus sampling threshold |
| `stop` | string or array | No | Up to 4 sequences that halt generation |
| `frequency_penalty` | number | No | Penalise tokens by how often they have appeared, `-2`–`2` |
| `presence_penalty` | number | No | Penalise tokens that have appeared at all, `-2`–`2` |

```bash
curl https://prod.api.market/api/v1/kelewenai/deepseek-api/v1/chat/completions \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Explain HTTP caching in two sentences."}
    ],
    "max_tokens": 200,
    "temperature": 0.7
  }'
```

Response:

```json
{
  "id": "65b0c938-770b-475b-bce1-5baafddfe0d4",
  "object": "chat.completion",
  "created": 1786962918,
  "model": "deepseek-v4-flash",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "..." },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 9,
    "completion_tokens": 1,
    "total_tokens": 10,
    "prompt_cache_hit_tokens": 0,
    "prompt_cache_miss_tokens": 9
  }
}
```

The `model` field in the response reports the underlying serving model, which may differ from the alias you requested. Continue to send `deepseek-chat` or `deepseek-reasoner` in your request.

#### Reasoning responses

When you call `deepseek-reasoner`, the assistant message carries an extra `reasoning_content` field holding the model's working, separate from the final `content`.

```bash
curl https://prod.api.market/api/v1/kelewenai/deepseek-api/v1/chat/completions \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-reasoner",
    "messages": [{"role": "user", "content": "What is 17 * 23?"}],
    "max_tokens": 400
  }'
```

```json
{
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "reasoning_content": "17 * 23 = 17 * 20 + 17 * 3 = 340 + 51 = 391",
        "content": "391"
      },
      "finish_reason": "stop"
    }
  ]
}
```

#### Streaming

Set `"stream": true` to receive `text/event-stream` chunks. Each chunk is a `data:` line containing a `chat.completion.chunk` object with a `delta`; the stream ends with `data: [DONE]`.

```bash
curl -N https://prod.api.market/api/v1/kelewenai/deepseek-api/v1/chat/completions \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat",
    "messages": [{"role": "user", "content": "Count from 1 to 5."}],
    "stream": true
  }'
```

#### GET /v1/models

Lists the models currently available on this endpoint. Takes no parameters.

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

```json
{
  "object": "list",
  "data": [
    {
      "id": "deepseek-chat",
      "object": "model",
      "created": 1626777600,
      "owned_by": "deepseek",
      "supported_endpoint_types": ["openai"]
    },
    {
      "id": "deepseek-reasoner",
      "object": "model",
      "created": 1626777600,
      "owned_by": "deepseek",
      "supported_endpoint_types": ["openai"]
    }
  ],
  "success": true
}
```

## Status Codes

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

## Rate Limits

Both plans allow up to **10 requests per second**. Quotas are enforced per billing period:

- **Free Trial** — 100 API units, hard limit. Requests are rejected once the quota is used up.
- **Mega** — 1,000 API units per month, soft limit, with overage billed per additional call.

Streaming and non-streaming requests consume the same number of units.

## Error Handling

Errors return a JSON body in OpenAI's error shape:

```json
{
  "error": {
    "code": "model_not_found",
    "message": "No available channel for model gpt-4o",
    "type": "new_api_error"
  }
}
```

Practical guidance:

- **Retry `429` and `5xx`** with exponential backoff, starting around 1 second and doubling up to roughly 30 seconds.
- **Do not retry `400` or `401`** — these mean the request or the key is wrong and will fail again identically.
- **Set a generous client timeout.** Non-streaming reasoning requests with a large `max_tokens` can take tens of seconds. Use streaming if you need to show progress.
- **Check `finish_reason`.** A value of `length` means the response was cut off by `max_tokens`, not that the model finished.

## Implementation Guide

### Example Code

**Python (OpenAI SDK)**

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[{"role": "user", "content": "Write a haiku about caching."}],
    max_tokens=200,
)

print(response.choices[0].message.content)
```

**Node.js (fetch)**

```javascript
const response = await fetch(
  "https://prod.api.market/api/v1/kelewenai/deepseek-api/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "x-api-market-key": process.env.API_MARKET_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "deepseek-reasoner",
      messages: [{ role: "user", content: "Is 91 prime? Explain briefly." }],
      max_tokens: 400,
    }),
  }
);

const data = await response.json();
console.log(data.choices[0].message.reasoning_content);
console.log(data.choices[0].message.content);
```

**Node.js (streaming)**

```javascript
const response = await fetch(
  "https://prod.api.market/api/v1/kelewenai/deepseek-api/v1/chat/completions",
  {
    method: "POST",
    headers: {
      "x-api-market-key": process.env.API_MARKET_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "deepseek-chat",
      messages: [{ role: "user", content: "Count from 1 to 5." }],
      stream: true,
    }),
  }
);

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  for (const line of decoder.decode(value).split("\n")) {
    if (!line.startsWith("data: ")) continue;
    const payload = line.slice(6);
    if (payload === "[DONE]") break;
    process.stdout.write(JSON.parse(payload).choices[0].delta.content ?? "");
  }
}
```

### Performance Optimization

- **Reuse prompt prefixes.** Keep your system prompt and any fixed context identical across calls so they hit the prompt cache. Watch `prompt_cache_hit_tokens` in the response to confirm it is working.
- **Pick the right model.** `deepseek-chat` is materially faster than `deepseek-reasoner`. Reserve the reasoner for problems that genuinely need multi-step work.
- **Cap `max_tokens`.** Latency scales with tokens generated, so set the smallest ceiling your use case tolerates.
- **Stream for anything user-facing.** Time to first token is far shorter than time to full response.
- **Trim conversation history.** Send a rolling window or a summary rather than the entire transcript on every turn.

## FAQ

**Do I need a DeepSeek account or API key?**

No. Your API.market key is the only credential you need. API.market authenticates with the upstream provider on your behalf.

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

Yes. Set `base_url` to `https://prod.api.market/api/v1/kelewenai/deepseek-api/v1` and pass your key in the `x-api-market-key` header via `default_headers`. The SDK's own `api_key` argument is not used.

**What is the difference between deepseek-chat and deepseek-reasoner?**

`deepseek-chat` answers directly and is faster. `deepseek-reasoner` works through the problem first and returns that working in a `reasoning_content` field alongside the final answer, which suits maths, logic and complex debugging.

**Why does the response `model` field show a different name than what I sent?**

The response reports the underlying serving model. Keep sending `deepseek-chat` or `deepseek-reasoner` as the alias in your requests.

**Is streaming supported?**

Yes. Set `"stream": true` and read the `text/event-stream` response. The stream terminates with `data: [DONE]`.

**What happens when I hit my quota?**

On the Free Trial the limit is hard, so further requests are rejected until the period resets. On Mega the limit is soft, so calls continue and overage is billed per additional request.

**Is there a free tier?**

Yes. The Free Trial gives you 100 API units over 7 days with no credit card required.

## 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.


Pay-as-you-go DeepSeek chat & reasoning API with OpenAI-compatible endpoints. Streaming supported. Get instant API keys.

DeepSeek API - OpenAI Compatible Chat & Reasoning

FREE

KelewenAI

Mega

Production-grade DeepSeek chat completions on an OpenAI-compatible endpoint. deepseek-chat & deepseek-reasoner, streaming supported, built for developers.