DeepSeek4Free

https://github.com/xtekky/deepseek4free
Admin
A Python package for interacting with the DeepSeek AI chat API, providing streaming responses,...
Tokens:5,057
Snippets:44
Trust Score:8.2
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Clone Repository and Install Dependencies

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Clone the DeepSeek4Free repository and install its dependencies using pip.

```bash
git clone https://github.com/yourusername/deepseek4free.git
cd deepseek4free
```

```bash
pip install -r requirements.txt
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Clone the DeepSeek4Free repository and install the exact dependency versions specified in requirements.txt. Ensure you have obtained your auth token from the browser console and stored it in a .env file.

```bash
# Clone the repository
git clone https://github.com/yourusername/deepseek4free.git
cd deepseek4free

# Install exact dependency versions
pip install -r requirements.txt
# requirements: curl-cffi==0.8.1b9, wasmtime, numpy, nodriver, drissionpage

# Obtain your auth token from the browser console at chat.deepseek.com
# Run this snippet in Chrome DevTools → Console:
# JSON.parse(localStorage.getItem("userToken")).value

# Store the token in a .env file
echo 'DEEPSEEK_AUTH_TOKEN=your_token_here' > .env
```

--------------------------------

### Create a New Chat Session

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Initiates a new chat session, which is necessary before starting a conversation or performing chat completions.

```python
# Start a conversation
chat_id = api.create_chat_session()
```

--------------------------------

### DeepSeekAPI.__init__

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Initializes the API client by authenticating with a provided token. It validates the token format and checks for the correct curl-cffi version. It also attempts to load Cloudflare cookies from a local file for persistent sessions.

```APIDOC
## DeepSeekAPI.__init__ — Initialize the API Client

Creates an authenticated API client. Validates the token format, checks the `curl-cffi` version, and loads any previously saved Cloudflare cookies from `dsk/cookies.json`.

```python
from dsk.api import DeepSeekAPI, AuthenticationError
import os
from dotenv import load_dotenv

load_dotenv()

try:
    api = DeepSeekAPI(os.getenv("DEEPSEEK_AUTH_TOKEN"))
    # If curl-cffi version is not 0.8.1b9, a warning is printed to stderr:
    # Warning: DeepSeek API requires curl-cffi version 0.8.1b9
except AuthenticationError as e:
    print(f"Invalid token: {e}")
```
```

--------------------------------

### Initialize DeepSeekAPI Client

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Initialize the DeepSeekAPI client with your authentication token. The client validates the token format and checks the curl-cffi version. It also loads Cloudflare cookies if available. Handle AuthenticationError if the token is invalid.

```python
from dsk.api import DeepSeekAPI, AuthenticationError
import os
from dotenv import load_dotenv

load_dotenv()

try:
    api = DeepSeekAPI(os.getenv("DEEPSEEK_AUTH_TOKEN"))
    # If curl-cffi version is not 0.8.1b9, a warning is printed to stderr:
    # Warning: DeepSeek API requires curl-cffi version 0.8.1b9
except AuthenticationError as e:
    print(f"Invalid token: {e}")
```

--------------------------------

### Send Initial and Follow-up Chat Messages

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Demonstrates sending an initial message and then a follow-up question within the same chat thread. Ensure you have a valid chat_id and handle the parent_message_id for threaded conversations.

```python
parent_id = None
for chunk in api.chat_completion(chat_id, "Tell me about neural networks"):
    if chunk['type'] == 'text':
        print(chunk['content'], end='', flush=True)
    elif 'message_id' in chunk:
        parent_id = chunk['message_id']

# Send follow-up question in the thread
for chunk in api.chat_completion(
    chat_id,
    "How do they compare to other ML models?",
    parent_message_id=parent_id
):
    if chunk['type'] == 'text':
        print(chunk['content'], end='', flush=True)
```

--------------------------------

### Basic DeepSeek API Chat Completion

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Initialize the DeepSeekAPI with your auth token, create a chat session, and perform a simple chat completion, printing the streamed response.

```python
from dsk.api import DeepSeekAPI

# Initialize with your auth token
api = DeepSeekAPI("YOUR_AUTH_TOKEN")

# Create a new chat session
chat_id = api.create_chat_session()

# Simple chat completion
prompt = "What is Python?"
for chunk in api.chat_completion(chat_id, prompt):
    if chunk['type'] == 'text':
        print(chunk['content'], end='', flush=True)
```

--------------------------------

### Basic Chat Completion and Threading

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Demonstrates how to perform a basic chat completion and how to thread subsequent messages using the `parent_message_id` parameter. Ensure `chat_id` is obtained prior to these calls.

```python
parent_id = None
for chunk in api.chat_completion(chat_id, "What is gradient descent?"):
    if chunk["type"] == "text":
        print(chunk["content"], end="", flush=True)
    if "message_id" in chunk:
        parent_id = chunk["message_id"]
print()

# Follow-up threaded to the first reply
for chunk in api.chat_completion(
    chat_id,
    "How does learning rate affect it?",
    parent_message_id=parent_id,
    thinking_enabled=True
):
    if chunk["type"] == "thinking":
        print(f"[Reasoning] {chunk['content']}")
    elif chunk["type"] == "text":
        print(chunk["content"], end="", flush=True)
print()
```

--------------------------------

### Solve DeepSeek Proof-of-Work Challenge

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Demonstrates how to use the `DeepSeekPOW` class to solve a server-issued computational challenge, returning a base64-encoded JSON string for the `x-ds-pow-response` header.

```python
from dsk.pow import DeepSeekPOW

pow_solver = DeepSeekPOW()

# A challenge dict as returned by the /chat/create_pow_challenge endpoint
challenge = {
    "algorithm": "DeepSeekHashV1",
    "challenge": "abc123challenge",
    "salt": "randomsalt",
    "difficulty": 100000,
    "expire_at": 1700000000,
    "signature": "sig_abc123",
    "target_path": "/api/v0/chat/completion"
}

# Returns a base64-encoded JSON string to set as x-ds-pow-response header
pow_response = pow_solver.solve_challenge(challenge)
print(pow_response)
# Output: eyJhbGdvcml0aG0iOiAiRGVlcFNlZWtIYXNoVjEiLCAiY2hhbGxlbmdlIjog...
```

--------------------------------

### DeepSeekAPI.chat_completion

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Sends a prompt to a specified chat session and returns a generator yielding response chunks in real-time. It supports optional visibility into the model's thinking process and can optionally integrate live web search.

```APIDOC
## DeepSeekAPI.chat_completion — Streaming Chat Completion

Sends a prompt to the given chat session and returns a generator that yields response chunks in real time. Each chunk is a `dict` with `type` (`"thinking"` or `"text"`), `content` (the token string), and optionally `finish_reason` (`"stop"` when done). Supports optional thinking-process visibility and web search.

```python
from dsk.api import (
    DeepSeekAPI, AuthenticationError, RateLimitError, NetworkError,
    CloudflareError, APIError
)

api = DeepSeekAPI("YOUR_AUTH_TOKEN")
chat_id = api.create_chat_session()

try:
    chunks = api.chat_completion(
        chat_session_id=chat_id,
        prompt="Explain the difference between TCP and UDP",
        thinking_enabled=True,   # Show model's reasoning steps
        search_enabled=False      # Set True for live web search
    )

    for chunk in chunks:
        if chunk["type"] == "thinking":
            print(f"[Thinking] {chunk['content']}", flush=True)
        elif chunk["type"] == "text":
            print(chunk["content"], end="", flush=True)
        if chunk.get("finish_reason") == "stop":
            break

except AuthenticationError:
    print("Token invalid or expired.")
except RateLimitError:
    print("Rate limit hit — wait before retrying.")
except CloudflareError as e:
    print(f"Cloudflare blocked the request: {e}")
except NetworkError as e:
    print(f"Network failure: {e}")
except APIError as e:
    print(f"API error {e.status_code}: {e}")
```
```

--------------------------------

### Bypass Cloudflare Challenges

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Run this Python command to automatically handle Cloudflare challenges by opening an undetected browser, solving the challenge, and saving the cf_clearance cookie.

```bash
python -m dsk.bypass
```

--------------------------------

### Handle Deepseek API Errors

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Shows how to import and use specific exceptions provided by the Deepseek API package for robust error handling. Wrap your API calls in a try-except block to catch potential issues like authentication failures, rate limits, or network problems.

```python
from dsk.api import (
    DeepSeekAPI, 
    AuthenticationError,
    RateLimitError,
    NetworkError,
    CloudflareError,
    APIError
)

try:
    api = DeepSeekAPI("YOUR_AUTH_TOKEN")
    chat_id = api.create_chat_session()
    
    for chunk in api.chat_completion(chat_id, "Your prompt here"):
        if chunk['type'] == 'text':
            print(chunk['content'], end='', flush=True)
            
except AuthenticationError:
    print("Authentication failed. Please check your token.")
except RateLimitError:
    print("Rate limit exceeded. Please wait before making more requests.")
except CloudflareError as e:
    print(f"Cloudflare protection encountered: {str(e)}")
except NetworkError:
    print("Network error occurred. Check your internet connection.")
except APIError as e:
    print(f"API error occurred: {str(e)}")
```

--------------------------------

### Streaming Chat Completion with Thinking Process

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Send a prompt to a chat session and receive response chunks as a generator. Each chunk can be 'thinking' or 'text'. Enable `thinking_enabled=True` to see the model's reasoning. Handle various potential errors like AuthenticationError, RateLimitError, CloudflareError, NetworkError, and general APIError.

```python
from dsk.api import (
    DeepSeekAPI, AuthenticationError, RateLimitError, NetworkError,
    CloudflareError, APIError
)

api = DeepSeekAPI("YOUR_AUTH_TOKEN")
chat_id = api.create_chat_session()

try:
    chunks = api.chat_completion(
        chat_session_id=chat_id,
        prompt="Explain the difference between TCP and UDP",
        thinking_enabled=True,   # Show model's reasoning steps
        search_enabled=False      # Set True for live web search
    )

    for chunk in chunks:
        if chunk["type"] == "thinking":
            print(f"[Thinking] {chunk['content']}", flush=True)
        elif chunk["type"] == "text":
            print(chunk["content"], end="", flush=True)
        if chunk.get("finish_reason") == "stop":
            break

except AuthenticationError:
    print("Token invalid or expired.")
except RateLimitError:
    print("Rate limit hit — wait before retrying.")
except CloudflareError as e:
    print(f"Cloudflare blocked the request: {e}")
except NetworkError as e:
    print(f"Network failure: {e}")
except APIError as e:
    print(f"API error {e.status_code}: {e}")
```

--------------------------------

### DeepSeekAPI.chat_completion (Threaded)

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Demonstrates how to use the `message_id` from response chunks to link follow-up messages, enabling the creation of branching conversation threads.

```APIDOC
## DeepSeekAPI.chat_completion — Threaded Conversations

Track `message_id` from response chunks to link follow-up messages to a specific parent, creating a branching conversation thread.

```python
from dsk.api import DeepSeekAPI

api = DeepSeekAPI("YOUR_AUTH_TOKEN")
chat_id = api.create_chat_session()

# Example usage for threaded conversations would follow here,
# demonstrating how to use message_id from previous responses
# to construct new prompts within a specific thread.
```
```

--------------------------------

### DeepSeek API Chat with Thinking Process

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Enable and display the model's thinking process during a chat completion by setting `thinking_enabled=True`.

```python
# With thinking process enabled
for chunk in api.chat_completion(
    chat_id,
    "Explain quantum computing",
    thinking_enabled=True
):
    if chunk['type'] == 'thinking':
        print(f"🤔 Thinking: {chunk['content']}")
    elif chunk['type'] == 'text':
        print(chunk['content'], end='', flush=True)
```

--------------------------------

### DeepSeekAPI.create_chat_session

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Creates a new stateful chat session on the DeepSeek backend. This session maintains conversation history, and its ID must be passed to subsequent `chat_completion` calls for that conversation.

```APIDOC
## DeepSeekAPI.create_chat_session — Create a New Chat Session

Creates a new stateful chat session on the DeepSeek backend and returns the session ID string. Each session maintains its own conversation history. Pass the returned ID to `chat_completion` for all messages in that conversation.

```python
from dsk.api import DeepSeekAPI, APIError

api = DeepSeekAPI("YOUR_AUTH_TOKEN")

try:
    chat_id = api.create_chat_session()
    print(f"Session created: {chat_id}")
    # Output: Session created: a1b2c3d4-e5f6-7890-abcd-ef1234567890
except APIError as e:
    print(f"Could not create session: {e} (status: {e.status_code})")
```
```

--------------------------------

### Create a New Chat Session

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Create a new stateful chat session on the DeepSeek backend to maintain conversation history. The returned session ID must be used for subsequent messages in that conversation. Handle APIError for session creation failures.

```python
from dsk.api import DeepSeekAPI, APIError

api = DeepSeekAPI("YOUR_AUTH_TOKEN")

try:
    chat_id = api.create_chat_session()
    print(f"Session created: {chat_id}")
    # Output: Session created: a1b2c3d4-e5f6-7890-abcd-ef1234567890
except APIError as e:
    print(f"Could not create session: {e} (status: {e.status_code})")
```

--------------------------------

### Chat Completion with Web Search Enabled

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Enables the model to fetch up-to-date information from the web before generating a response by setting `search_enabled=True`. Thinking chunks may describe the search process.

```python
from dsk.api import DeepSeekAPI

api = DeepSeekAPI("YOUR_AUTH_TOKEN")
chat_id = api.create_chat_session()

for chunk in api.chat_completion(
    chat_id,
    "What are the latest AI model releases this week?",
    thinking_enabled=True,
    search_enabled=True
):
    if chunk["type"] == "thinking":
        print(f"🔍 {chunk['content']}")
    elif chunk["type"] == "text":
        print(chunk["content"], end="", flush=True)
print()
```

--------------------------------

### DeepSeek API Chat with Web Search

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Integrate web search for up-to-date information by setting `search_enabled=True` and `thinking_enabled=True`.

```python
# With web search enabled
for chunk in api.chat_completion(
    chat_id,
    "What are the latest developments in AI?",
    thinking_enabled=True,
    search_enabled=True
):
    if chunk['type'] == 'thinking':
        print(f"🔍 Searching: {chunk['content']}")
    elif chunk['type'] == 'text':
        print(chunk['content'], end='', flush=True)
```

--------------------------------

### Run Cloudflare Bypass Script

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Executes the Cloudflare bypass script to solve challenges and save cookies. This is typically run from the project root.

```bash
# Run the Cloudflare bypass from the project root
python -m dsk.bypass

# Expected output:
# Getting the cookies...
# Attempt 1: Verification page detected. Trying to bypass...
# Bypass successful.
# Successfully obtained and saved cookies with cf_clearance!
```

--------------------------------

### Cloudflare Bypass Cookie File Structure

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Illustrates the expected JSON structure for `dsk/cookies.json` which stores Cloudflare bypass cookies and user agent. The `DeepSeekAPI` client automatically loads this file.

```json
# The saved cookie file structure (dsk/cookies.json)
{
    "cookies": {
        "cf_clearance": "abc123xyz...",
        "__cf_bm": "...",
        "...": "..."
    },
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ..."
}

# DeepSeekAPI reads this file automatically — no manual steps needed after bypass
from dsk.api import DeepSeekAPI
api = DeepSeekAPI("YOUR_AUTH_TOKEN")  # cookies loaded from dsk/cookies.json
```

--------------------------------

### Extract DeepSeek Auth Token from Local Storage

Source: https://github.com/xtekky/deepseek4free/blob/main/README.md

Use this JavaScript snippet in your browser's developer console to extract your DeepSeek authentication token from local storage.

```javascript
JSON.parse(localStorage.getItem("userToken")).value
```

--------------------------------

### Threaded Conversations with Message IDs

Source: https://context7.com/xtekky/deepseek4free/llms.txt

Utilize `message_id` from response chunks to link follow-up messages to a specific parent, enabling the creation of branching conversation threads within a chat session.

```python
from dsk.api import DeepSeekAPI

api = DeepSeekAPI("YOUR_AUTH_TOKEN")
chat_id = api.create_chat_session()


```
Tokens:
Raw