Free DeepSeek API

┌──────────────┐      OpenAI /v1/chat/completions      ┌──────────────────────┐      PoW + Bearer       ┌───────────────────┐
│  App / Agent │  ───────────────────────────────────▶  │  Free DeepSeek API  │  ────────────────────▶  │ chat.deepseek.com │
│  (SDK, IDE)  │  ◀────────── SSE / JSON ─────────────  │  (this proxy)       │  ◀───── SSE/JSON ─────  │   (web endpoint)  │
└──────────────┘                                        └──────────────────────┘                         └───────────────────┘

git clone https://github.com/zeroaiproject/Free-DeepSeek-API.git
cd free-deepseek-api
cp .env.example .env                  # optional (auto-loaded)
echo "$DEEPSEEK_USER_TOKEN" > tokens.txt
./run.sh                              # or: npm start | docker compose up -d

curl http://127.0.0.1:8787/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "deepseek-chat",
    "messages": [{"role": "user", "content": "Say hello in one sentence."}]
  }'

# streaming SSE
curl -N http://127.0.0.1:8787/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"deepseek-chat","stream":true,"messages":[{"role":"user","content":"Count from 1 to 5."}]}'

# health + metrics (masked tokens)
curl http://127.0.0.1:8787/health

# models & capabilities
curl http://127.0.0.1:8787/v1/models

The proxy requires a userToken (stored by the DeepSeek web app after login).

Google accounts without a password: set one via "forgot password" (one-time manual step) to enable automatic re-login (DEEPSEEK_EMAIL/PASSWORD). Details and troubleshooting: tutos/SETUP.md.

The proxy reproduces the chat.deepseek.com web flow and exposes it as an OpenAI-compatible API. At a high level: bearer auth (userToken) → per-request PoW → chat session → SSE completion → OpenAI translation.

Client (SDK/agent)                     Local proxy                         DeepSeek web
      │                                     │                                   │
      │  POST /v1/chat/completions          │                                   │
      ├────────────────────────────────────▶│  create_pow_challenge             │
      │                                     ├──────────────────────────────────▶│
      │                                     │◀───────── challenge ──────────────┤
      │                                     │  solve PoW (WASM, ~30–110ms)      │
      │                                     │  create/reuse chat_session        │
      │                                     ├──────────────────────────────────▶│
      │                                     │  POST /chat/completion (SSE)      │
      │                                     ├──────────────────────────────────▶│
      │  SSE chunks / OpenAI JSON           │◀──── fragments / patches ─────────┤
      │◀────────────────────────────────────│  assemble + map (THINK/tools)     │

Each completion requires an X-Ds-Pow-Response header:

1. Challenge — POST /api/v0/chat/create_pow_challenge with target_path → algorithm, challenge, salt, signature, difficulty, expire_at, target_path.
2. Solve — find answer ∈ [0, difficulty] such that DeepSeekHash(salt_expireAt_answer) == challenge.
   • Custom Keccak algorithm embedded in lib/sha3_wasm_bg.7b9ca65ddd.wasm (executed as-is, not standard SHA-256/SHA3).
3. Proof — Base64-encoded JSON: {"algorithm","challenge","salt","answer","signature","target_path"}.

Unsolved challenges can be pre-warmed (TTL ~300 s); a solved proof is single-use.

4. Session — POST /api/v0/chat_session/create returns a chat_session.id reused for a few requests then rotated (latency/noise trade-off).
5. Flattened transcript — the proxy converts OpenAI messages (system/user/assistant/tool) into the text prompt expected by the web endpoint. It advertises up to a 1M token window (/v1/models), but the effective limit depends on the upstream endpoint/account.
6. Completion — POST /api/v0/chat/completion with model: default|thinking, prompt, and params; response is SSE.

The DeepSeek stream (snapshots response.fragments, appends {"v":"..."}, targeted replacements/patches, status events) is reassembled and mapped:

• THINK fragments → reasoning_content (deepseek-reasoner)
• text fragments → delta.content / message.content
• end of stream → finish_reason (stop / tool_calls), relayed aggregate usage

The web endpoint has no native function calling; the proxy emulates it:

• Injects tools schemas into a system instruction block (names, JSON Schema, rules, tool_choice/parallel_tool_calls).
• Parses replies into OpenAI tool_calls from JSON ({"tool_calls":[...]}) or native DSML markup (<｜DSML｜ invoke/parameter>), with argument normalization/coercion.
• Stream-safe: streamgate holds back a short tail (STREAM_HOLD_BACK) and stops text emission once a tool-call marker is detected to prevent markup leaks.
• Round-trip: role:"tool" messages are reinjected into the transcript for subsequent turns.

• Token pool: round-robin, hot-reload of tokens.txt, masked in /health, penalties/cooldowns.
• Rate limiting: bucket + min gap + jitter + escalating cooldown, 1 in-flight completion per token, staggered pre-warming of challenges/sessions (absorbs silent throttling and reduces bursty patterns).
• Watchdog: jittered liveness probes, distinguishes revocation (recoverable 40003) from suspension (not recoverable), optional auto re-login when credentials are configured.
• Observability: /health, /metrics (Prometheus/JSON), X-Request-Id, X-Ds-* timings, optional lightweight logs without bodies/secrets.

Effective window depends on upstream acceptance. usage reflects upstream aggregate (no prompt/completion split).

curl http://127.0.0.1:8787/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "deepseek-chat",
    "messages": [{"role":"user","content":"What is the weather in Paris?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Current weather for a city",
        "parameters": {"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}
      }
    }]
  }'

All tutorials: tutos/ — base http://127.0.0.1:8787/v1, models deepseek-chat / deepseek-reasoner, dummy key public if required.

All variables are optional. .env is auto-loaded (without overriding existing vars). Secrets (.env, tokens.txt) are gitignored; tokens are persisted with mode 0600.

Full list including signup/captcha/mailbox variables: .env.example and tutos/SETUP.md.

• No refresh token: only login/register/oauth mint a userToken — tokens are replaced, not refreshed.
• 40003 is ambiguous: revocation (re-login may help) vs suspension (all endpoints fail, wait it out) — the proxy distinguishes, backs off, and reports state in /health.
• Silent throttling: empty responses after bursts; the proxy paces, waits, and retries (progressive backoff).
• Anti-suspension is not guaranteed: pacing/jitter/gaps, session reuse, staggered pre-warm and watchdog reduce signals but cannot eliminate policy risk.

server.js                 HTTP server, OpenAI layer, routing, metrics
lib/
  deepseek.js             Upstream client (challenge/session/completion, proxy tunnel)
  pow.js                  WASM PoW solver
  stream.js               SSE assembly → fragments
  streamgate.js           Stream hold-back / tool-call marker detection
  tools.js                Tool emulation (prompt, JSON/DSML parsing, transcript)
  pool.js                 Token pool, hot-reload, swap/re-login
  ratelimit.js            Bucket + mutex + pacing/jitter/cooldown
  warm.js                 Pre-warm challenges/sessions
  watchdog.js             Liveness probe, triggers re-login
  auth.js / signup.js     Login and signup (experimental)
  captcha.js / mailbox.js Captcha solvers & verification-code readers
  metrics.js / env.js     Metrics and .env loading
scripts/                  login, signup, tests, bench, probes
tutos/                    Integration guides (OpenCode, Cursor, Cline, Aider, etc.)
run.sh                    start/restart helper (pidfile)

docker build -t free-deepseek-api .
docker run -p 8787:8787 -e API_KEY=sk-local -v "$PWD/tokens.txt:/app/tokens.txt:ro" free-deepseek-api
# or
docker compose up -d --build

npm run test:offline   # parsers + streamgate + PoW (no network)
npm run test:all       # offline + signup gate smoke (network)
node --check server.js lib/*.js scripts/*.js