Chat API Endpoints

DeepWikiOpen provides powerful chat capabilities with streaming responses, deep research mode, conversation management, and real-time WebSocket connections.

Authentication

All chat endpoints require authentication using Bearer tokens:

Authorization: Bearer <your-api-key>

Rate Limits

Standard Chat: 100 requests per minute
Research Mode: 20 requests per minute
WebSocket: 1000 messages per minute
History Operations: 200 requests per minute

POST /chat/stream

Stream chat responses with RAG (Retrieval-Augmented Generation) capabilities.

string

required

The user’s message or question

string

Unique identifier for conversation continuity. Auto-generated if not provided.

string

default:"gpt-4-turbo"

AI model to use for response generationOptions: gpt-4-turbo, gpt-3.5-turbo, claude-3-opus, claude-3-sonnet

number

default:"0.7"

Response creativity (0.0 to 2.0)

number

default:"2048"

Maximum response length (1 to 4096)

array

Specific knowledge sources to queryOptions: wikipedia, academic_papers, news, documentation, all

object

Streaming configuration options

boolean

default:"true"

Include source citations in stream

boolean

default:"false"

Include processing metadata

Request Example

curl -X POST "https://api.deepwikiopen.com/chat/stream" \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Explain quantum computing and its applications",
    "conversation_id": "conv_123",
    "model": "gpt-4-turbo",
    "temperature": 0.7,
    "context_sources": ["wikipedia", "academic_papers"],
    "stream_options": {
      "include_sources": true,
      "include_metadata": true
    }
  }'

import requests
import json

def stream_chat(message):
    url = "https://api.deepwikiopen.com/chat/stream"
    headers = {
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    }
    
    data = {
        "message": message,
        "model": "gpt-4-turbo",
        "temperature": 0.7,
        "context_sources": ["wikipedia", "academic_papers"],
        "stream_options": {
            "include_sources": True
        }
    }
    
    response = requests.post(url, headers=headers, json=data, stream=True)
    
    for line in response.iter_lines():
        if line:
            decoded_line = line.decode('utf-8')
            if decoded_line.startswith('data: '):
                try:
                    chunk = json.loads(decoded_line[6:])
                    if chunk.get('type') == 'content':
                        print(chunk['content'], end='', flush=True)
                except json.JSONDecodeError:
                    pass

stream_chat("Explain quantum computing and its applications")

async function streamChat(message) {
  const response = await fetch('https://api.deepwikiopen.com/chat/stream', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-api-key',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: message,
      model: 'gpt-4-turbo',
      temperature: 0.7,
      context_sources: ['wikipedia', 'academic_papers'],
      stream_options: {
        include_sources: true
      }
    })
  });

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

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

      const chunk = decoder.decode(value);
      const lines = chunk.split('\n');

      for (const line of lines) {
        if (line.startsWith('data: ')) {
          try {
            const data = JSON.parse(line.slice(6));
            if (data.type === 'content') {
              process.stdout.write(data.content);
            }
          } catch (e) {
            // Skip invalid JSON
          }
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

streamChat('Explain quantum computing and its applications');

Streaming Response Format (SSE)

The response is streamed using Server-Sent Events (SSE) format:

string

Type of stream chunkValues: start, content, sources, metadata, end, error

string

Text content (for content type chunks)

array

Retrieved knowledge sources (for sources type chunks)

string

Source document title

string

Source URL or identifier

string

Relevant text excerpt

number

Relevance score (0.0 to 1.0)

object

Processing metadata (for metadata type chunks)

number

Total tokens consumed

number

Processing time in milliseconds

number

Number of sources searched

Example Stream Response

data: {"type": "start", "conversation_id": "conv_123", "timestamp": "2024-01-15T10:30:00Z"}

data: {"type": "content", "content": "Quantum computing is a revolutionary"}

data: {"type": "content", "content": " approach to computation that leverages"}

data: {"type": "sources", "sources": [
  {
    "title": "Quantum Computing - Wikipedia",
    "url": "https://en.wikipedia.org/wiki/Quantum_computing",
    "snippet": "Quantum computing is a type of computation whose operations can harness the phenomena of quantum mechanics...",
    "relevance_score": 0.92
  }
]}

data: {"type": "content", "content": " quantum mechanical phenomena..."}

data: {"type": "metadata", "metadata": {"tokens_used": 156, "processing_time": 1250, "sources_queried": 5}}

data: {"type": "end", "conversation_id": "conv_123", "total_tokens": 156}

POST /chat/research

Trigger deep research mode for comprehensive, multi-source analysis.

string

required

Research question or topic

string

default:"standard"

Depth of research analysisOptions: quick, standard, deep, comprehensive

array

Types of sources to include in researchOptions: academic, wikipedia, news, documentation, books, patents

object

Filter sources by publication date

string

Start date (ISO 8601 format)

string

End date (ISO 8601 format)

number

default:"20"

Maximum number of sources to analyze (5 to 100)

string

default:"structured"

Response format structureOptions: structured, narrative, bullet_points, academic

Request Example

curl -X POST "https://api.deepwikiopen.com/chat/research" \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Latest developments in CRISPR gene editing 2024",
    "research_depth": "deep",
    "source_types": ["academic", "news", "patents"],
    "time_range": {
      "start_date": "2024-01-01",
      "end_date": "2024-12-31"
    },
    "max_sources": 50,
    "output_format": "structured"
  }'

import requests

def deep_research(query):
    url = "https://api.deepwikiopen.com/chat/research"
    headers = {
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    }
    
    data = {
        "query": query,
        "research_depth": "deep",
        "source_types": ["academic", "news", "patents"],
        "time_range": {
            "start_date": "2024-01-01",
            "end_date": "2024-12-31"
        },
        "max_sources": 50,
        "output_format": "structured"
    }
    
    response = requests.post(url, headers=headers, json=data)
    return response.json()

result = deep_research("Latest developments in CRISPR gene editing 2024")
print(result)

async function deepResearch(query) {
  const response = await fetch('https://api.deepwikiopen.com/chat/research', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your-api-key',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      query: query,
      research_depth: 'deep',
      source_types: ['academic', 'news', 'patents'],
      time_range: {
        start_date: '2024-01-01',
        end_date: '2024-12-31'
      },
      max_sources: 50,
      output_format: 'structured'
    })
  });

  return await response.json();
}

deepResearch('Latest developments in CRISPR gene editing 2024')
  .then(result => console.log(result));

Response Format

string

Unique identifier for the research session

string

Original research query

string

Executive summary of findings

array

Main discoveries and insights

string

Key insight or discovery

number

Confidence score (0.0 to 1.0)

array

Sources supporting this finding

string

Comprehensive analysis text

array

All sources analyzed

string

Source title

array

Author names

string

Publication date

string

Source URL

number

Relevance to query (0.0 to 1.0)

array

Important points from source

object

Research session metadata

number

Total sources processed

number

Time taken in seconds

number

Overall confidence in findings

GET /chat/history

Retrieve conversation history for a specific conversation or user.

string

Specific conversation ID to retrieve

string

User ID to get all conversations for

number

default:"50"

Maximum number of messages to return (1 to 1000)

number

default:"0"

Number of messages to skip for pagination

string

Filter messages after this date (ISO 8601)

string

Filter messages before this date (ISO 8601)

Request Example

curl -X GET "https://api.deepwikiopen.com/chat/history?conversation_id=conv_123&limit=100" \
  -H "Authorization: Bearer your-api-key"

import requests

def get_chat_history(conversation_id, limit=50):
    url = f"https://api.deepwikiopen.com/chat/history"
    headers = {"Authorization": "Bearer your-api-key"}
    
    params = {
        "conversation_id": conversation_id,
        "limit": limit
    }
    
    response = requests.get(url, headers=headers, params=params)
    return response.json()

history = get_chat_history("conv_123", limit=100)

async function getChatHistory(conversationId, limit = 50) {
  const params = new URLSearchParams({
    conversation_id: conversationId,
    limit: limit.toString()
  });

  const response = await fetch(`https://api.deepwikiopen.com/chat/history?${params}`, {
    headers: {
      'Authorization': 'Bearer your-api-key'
    }
  });

  return await response.json();
}

getChatHistory('conv_123', 100);

Response Format

string

Conversation identifier

array

Array of conversation messages

string

Unique message identifier

string

Message sender roleValues: user, assistant, system

string

Message content

string

Message timestamp (ISO 8601)

object

Additional message data

string

AI model that generated response

number

Tokens consumed for this message

array

Knowledge sources used

object

Pagination information

number

Total messages in conversation

boolean

Whether more messages are available

number

Offset for next page

DELETE /chat/history

Clear conversation history for a specific conversation or user.

string

Specific conversation to clear (optional if user_id provided)

string

Clear all conversations for user (optional if conversation_id provided)

string

Only clear messages before this date (ISO 8601)

Request Example

curl -X DELETE "https://api.deepwikiopen.com/chat/history" \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "conversation_id": "conv_123"
  }'

import requests

def clear_chat_history(conversation_id):
    url = "https://api.deepwikiopen.com/chat/history"
    headers = {
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    }
    
    data = {"conversation_id": conversation_id}
    response = requests.delete(url, headers=headers, json=data)
    return response.json()

result = clear_chat_history("conv_123")

async function clearChatHistory(conversationId) {
  const response = await fetch('https://api.deepwikiopen.com/chat/history', {
    method: 'DELETE',
    headers: {
      'Authorization': 'Bearer your-api-key',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      conversation_id: conversationId
    })
  });

  return await response.json();
}

clearChatHistory('conv_123');

Response Format

boolean

Whether the operation was successful

number

Number of messages deleted

number

Number of conversations affected

WebSocket /ws/chat

Real-time bidirectional chat connection with live streaming and collaborative features.

Connection URL

wss://api.deepwikiopen.com/ws/chat?token=your-api-key&conversation_id=conv_123

Query Parameters

string

required

Your API authentication token

string

Conversation ID to connect to (auto-generated if not provided)

string

User identifier for multi-user conversations

Connection Example

const ws = new WebSocket('wss://api.deepwikiopen.com/ws/chat?token=your-api-key&conversation_id=conv_123');

ws.onopen = function(event) {
  console.log('Connected to chat WebSocket');
  
  // Send initial message
  ws.send(JSON.stringify({
    type: 'message',
    content: 'Hello, can you help me with quantum computing?',
    model: 'gpt-4-turbo'
  }));
};

ws.onmessage = function(event) {
  const data = JSON.parse(event.data);
  console.log('Received:', data);
  
  switch(data.type) {
    case 'content':
      // Stream AI response content
      process.stdout.write(data.content);
      break;
    case 'user_message':
      // Another user's message in group chat
      console.log(`${data.user}: ${data.content}`);
      break;
    case 'typing':
      // Typing indicator
      console.log(`${data.user} is typing...`);
      break;
  }
};

ws.onerror = function(error) {
  console.error('WebSocket error:', error);
};

ws.onclose = function(event) {
  console.log('Disconnected from chat WebSocket');
};

import asyncio
import websockets
import json

async def chat_websocket():
    uri = "wss://api.deepwikiopen.com/ws/chat?token=your-api-key&conversation_id=conv_123"
    
    async with websockets.connect(uri) as websocket:
        # Send initial message
        await websocket.send(json.dumps({
            "type": "message",
            "content": "Hello, can you help me with quantum computing?",
            "model": "gpt-4-turbo"
        }))
        
        # Listen for responses
        async for message in websocket:
            data = json.loads(message)
            
            if data["type"] == "content":
                print(data["content"], end="", flush=True)
            elif data["type"] == "user_message":
                print(f"\n{data['user']}: {data['content']}")
            elif data["type"] == "typing":
                print(f"\n{data['user']} is typing...")

# Run the WebSocket client
asyncio.run(chat_websocket())

Message Types

Client to Server Messages

string

required

Message typeValues: message, typing, stop_generation, join_room, leave_room

string

Message content (for message type)

string

AI model to use (for message type)

string

Room to join/leave (for room operations)

Server to Client Messages

string

Response typeValues: content, sources, user_message, typing, error, connection_info

string

Response content or user message

string

Username for user messages and typing indicators

string

Current conversation identifier

object

Error information (for error type)

string

Error code

string

Error description

Real-time Features

Typing Indicators

// Send typing indicator
ws.send(JSON.stringify({
  type: 'typing',
  is_typing: true
}));

// Stop typing indicator
ws.send(JSON.stringify({
  type: 'typing',
  is_typing: false
}));

Multi-user Chat Rooms

// Join a chat room
ws.send(JSON.stringify({
  type: 'join_room',
  room_id: 'quantum_physics_discussion'
}));

// Leave a chat room
ws.send(JSON.stringify({
  type: 'leave_room',
  room_id: 'quantum_physics_discussion'
}));

Stop AI Generation

// Stop the AI from generating more content
ws.send(JSON.stringify({
  type: 'stop_generation'
}));

Error Handling

HTTP Error Codes

Bad Request

Invalid request parameters or malformed JSON

Unauthorized

Missing or invalid API key

Forbidden

Insufficient permissions or quota exceeded

Not Found

Conversation or resource not found

Too Many Requests

Rate limit exceeded

Internal Server Error

Server error - try again later

Error Response Format

{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Rate limit exceeded. Try again in 60 seconds.",
    "details": {
      "retry_after": 60,
      "current_usage": 100,
      "limit": 100
    }
  }
}

WebSocket Error Codes

Invalid Token

Authentication token is invalid or expired

Rate Limited

Too many messages sent too quickly

Invalid Message

Message format is invalid or unsupported

Conversation Not Found

Specified conversation ID doesn’t exist

Real Conversation Examples

Basic Q&A with Streaming

# Request
curl -X POST "https://api.deepwikiopen.com/chat/stream" \
  -H "Authorization: Bearer demo-key" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "What causes climate change?",
    "context_sources": ["wikipedia", "academic_papers"]
  }'

# Streaming Response
data: {"type": "start", "conversation_id": "conv_abc123"}

data: {"type": "content", "content": "Climate change is primarily caused by human activities that increase"}

data: {"type": "content", "content": " greenhouse gas concentrations in the atmosphere. The main causes include:"}

data: {"type": "sources", "sources": [
  {
    "title": "Climate Change - IPCC Report 2023",
    "url": "https://www.ipcc.ch/report/ar6/",
    "snippet": "Human influence has unequivocally warmed the planet...",
    "relevance_score": 0.95
  }
]}

data: {"type": "content", "content": "\n\n**1. Fossil Fuel Combustion**\nBurning coal, oil, and natural gas..."}

data: {"type": "end", "conversation_id": "conv_abc123", "total_tokens": 342}

Deep Research Mode

# Research Request
curl -X POST "https://api.deepwikiopen.com/chat/research" \
  -H "Authorization: Bearer demo-key" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Impact of AI on healthcare diagnostics",
    "research_depth": "comprehensive",
    "source_types": ["academic", "news", "documentation"],
    "max_sources": 25
  }'

# Response (truncated for brevity)
{
  "research_id": "research_xyz789",
  "query": "Impact of AI on healthcare diagnostics",
  "summary": "AI is revolutionizing healthcare diagnostics through machine learning algorithms that can analyze medical images, predict disease outcomes, and assist in early detection with unprecedented accuracy...",
  "key_findings": [
    {
      "finding": "AI diagnostic systems show 94% accuracy in detecting skin cancer vs 86% for dermatologists",
      "confidence": 0.92,
      "supporting_sources": ["Nature Medicine 2024", "JAMA Dermatology 2024"]
    }
  ],
  "sources": [
    {
      "title": "AI in Medical Diagnosis: A Systematic Review",
      "authors": ["Smith, J.", "Chen, L.", "Kumar, R."],
      "publication_date": "2024-03-15",
      "url": "https://doi.org/10.1038/s41591-024-2847-2",
      "relevance_score": 0.96,
      "key_points": [
        "Machine learning models outperform traditional diagnostic methods",
        "Reduced diagnostic errors by 23% in clinical trials"
      ]
    }
  ]
}

WebSocket Multi-user Chat

// User A connects and sends message
const wsA = new WebSocket('wss://api.deepwikiopen.com/ws/chat?token=user-a-key&room_id=ai_discussion');

wsA.send(JSON.stringify({
  type: 'message',
  content: 'What are the latest developments in transformer models?'
}));

// User B receives the message and AI response
// Message from User A: {"type": "user_message", "user": "UserA", "content": "What are..."}
// AI starts responding: {"type": "content", "content": "The latest developments..."}

// User B sends a follow-up
const wsB = new WebSocket('wss://api.deepwikiopen.com/ws/chat?token=user-b-key&room_id=ai_discussion');

wsB.send(JSON.stringify({
  type: 'message',
  content: 'Can you elaborate on attention mechanisms?'
}));

SDK Libraries

For easier integration, use our official SDK libraries:

Python: pip install deepwikiopen
JavaScript/Node.js: npm install deepwikiopen-sdk
Go: go get github.com/deepwikiopen/go-sdk
Rust: cargo add deepwikiopen

Each SDK provides typed interfaces, automatic retry logic, streaming support, and WebSocket management.

​Chat API Endpoints

​Authentication

​Rate Limits

​POST /chat/stream

​Request Example

​Streaming Response Format (SSE)

​Example Stream Response

​POST /chat/research

​Request Example

​Response Format

​GET /chat/history

​Request Example

​Response Format

​DELETE /chat/history

​Request Example

​Response Format

​WebSocket /ws/chat

​Connection URL

​Query Parameters

​Connection Example

​Message Types

​Client to Server Messages

​Server to Client Messages

​Real-time Features

​Typing Indicators

​Multi-user Chat Rooms

​Stop AI Generation

​Error Handling

​HTTP Error Codes

​Error Response Format

​WebSocket Error Codes

​Real Conversation Examples

​Basic Q&A with Streaming

​Deep Research Mode

​WebSocket Multi-user Chat

​SDK Libraries

Chat API Endpoints

Authentication

Rate Limits

POST /chat/stream

Request Example

Streaming Response Format (SSE)

Example Stream Response

POST /chat/research

Request Example

Response Format

GET /chat/history

Request Example

Response Format

DELETE /chat/history

Request Example

Response Format

WebSocket /ws/chat

Connection URL

Query Parameters

Connection Example

Message Types

Client to Server Messages

Server to Client Messages

Real-time Features

Typing Indicators

Multi-user Chat Rooms

Stop AI Generation

Error Handling

HTTP Error Codes

Error Response Format

WebSocket Error Codes

Real Conversation Examples

Basic Q&A with Streaming

Deep Research Mode

WebSocket Multi-user Chat

SDK Libraries