Table of Contents
Assisters API Guide: How to Integrate AI Into Your App in 2026
Quick Answer
The Assisters API is OpenAI-compatible and available to Pro subscribers at https://assisters.dev/api/v1.↗ Use the openai npm or Python package with a changed base URL — no new SDK required. Available endpoints: chat completions, embeddings, models, moderation, audio transcriptions, and rerank.
Integration at a glance:
- Base URL: https://assisters.dev/api/v1↗
- Auth: Bearer token (your Assisters API key, stored as an environment variable)
- Default model: assisters-chat-v1
- SDK: use the openai package (npm or pip) — zero SDK rewrite
- Pro plan required for full API access ($9/month, 14-day trial available)
What Is the Assisters API?
The Assisters API is an OpenAI-compatible REST API provided by Assisters (assisters.dev). It gives developers programmatic access to AI text generation, vector embeddings, content moderation, audio transcription, and relevance reranking — all from a single endpoint with flat-fee Pro pricing.
Because it follows the OpenAI API spec exactly, you do not need to learn a new SDK or change your existing code structure. For developers already using the OpenAI SDK, migration is a single environment variable change.
Key Endpoints
Endpoint
Purpose
Streaming
POST /chat/completions
Text generation, chat, summarization
Yes
POST /embeddings
Convert text to float vectors
No
GET /models
List available models
No
POST /moderate
Content safety classification
No
POST /audio/transcriptions
Speech-to-text
No
POST /rerank
Rank results by relevance
No
Assisters API vs OpenAI API: Developer Comparison
Factor
Assisters API
OpenAI API
Pricing
$9/month flat (Pro)
Per-token billing
SDK compatibility
Full OpenAI SDK
Native
Chat completions
Yes
Yes
Streaming
Yes
Yes
Embeddings
Yes
Yes
Image generation
No
Yes (DALL-E)
Fine-tuning
No
Yes
Function calling
Check current docs
Yes
Moderation endpoint
Yes
Yes
Audio transcription
Yes
Yes
Reranking
Yes
No (separate providers)
Cost predictability
High
Variable
Who Should Use the Assisters API?
1. Developers building content apps
Blog generators, email writers, summarizers, chatbots — the chat completions endpoint handles all of these with streaming support for real-time output.
2. Teams building semantic search
The embeddings endpoint produces vector representations of text that can be stored in pgvector, Pinecone, or any vector database. Combine with the rerank endpoint for high-quality RAG pipelines.
3. Developers who need content moderation
The moderation endpoint classifies potentially harmful content before it reaches your users or gets stored in your database — a single API call for safety filtering.
4. Product builders who want cost predictability
At $9/month flat, you know your AI infrastructure cost before the month starts. No surprise bills when traffic spikes.
How to Integrate: Complete Developer Guide
Step 1: Get Your API key
Sign up at assisters.dev↗, start the 14-day Pro trial (credit card required, not charged for 14 days), go to Dashboard then API Settings, and generate your key. Store it in your project's environment variables — never commit it to source control.
Step 2: Install the SDK
Install the standard openai npm package (or pip package for Python). No Assisters-specific package needed.
Step 3: Initialize the Client
The only change from a standard OpenAI setup is the base URL. Your key is read from the environment:
import OpenAI from 'openai';
const client = new OpenAI({ baseURL: 'https://assisters.dev/api/v1', apiKey: process.env.ASSISTERS_API_KEY });
Python version (key on the same line as the constructor):
from openai import OpenAI
import os
client = OpenAI(base_url="https://assisters.dev/api/v1", api_key=os.environ["ASSISTERS_API_KEY"])
Step 4: Chat Completions
Basic non-streaming request:
const response = await client.chat.completions.create({
model: 'assisters-chat-v1',
messages: [
{ role: 'system', content: 'You are a helpful assistant.' },
{ role: 'user', content: 'Summarize TypeScript benefits in 3 bullet points.' },
],
max_tokens: 300,
});
console.log(response.choices[0].message.content);
Streaming (tokens arrive in real time):
const stream = await client.chat.completions.create({
model: 'assisters-chat-v1',
messages: [{ role: 'user', content: 'Write a blog intro about remote work.' }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}
Next.js streaming API route:
import OpenAI from 'openai';
import { OpenAIStream, StreamingTextResponse } from 'ai';
const client = new OpenAI({ baseURL: 'https://assisters.dev/api/v1', apiKey: process.env.ASSISTERS_API_KEY });
export async function POST(req: Request) {
const { prompt } = await req.json();
const response = await client.chat.completions.create({
model: 'assisters-chat-v1',
messages: [{ role: 'user', content: prompt }],
stream: true,
});
return new StreamingTextResponse(OpenAIStream(response));
}
Step 5: Embeddings
const result = await client.embeddings.create({ model: 'assisters-chat-v1', input: 'How do I reset my password?' });
const vector = result.data[0].embedding; // float[]
RAG pattern — semantic search with pgvector:
const qEmbed = await client.embeddings.create({ model: 'assisters-chat-v1', input: userQuery });
const docs = await supabase.rpc('match_documents', {
query_embedding: qEmbed.data[0].embedding,
match_threshold: 0.78,
match_count: 5,
});
const answer = await client.chat.completions.create({
model: 'assisters-chat-v1',
messages: [
{ role: 'system', content: 'Answer using this context: ' + docs.data.map((d: { content: string }) => d.content).join(' ') },
{ role: 'user', content: userQuery },
],
});
Step 6: Content Moderation
const check = await client.moderations.create({ input: userContent });
if (check.results[0].flagged) {
// reject or queue for manual review
}
Step 7: List Available Models
const models = await client.models.list();
models.data.forEach(m => console.log(m.id));
Common Integration Patterns
Pattern 1: AI-powered blog writing tool
Chat completions with streaming to editor — user reviews and publishes.
Pattern 2: Customer support chatbot
Embeddings for knowledge base, rerank for best matches, chat completions with retrieved context.
Pattern 3: User content safety pipeline
User submits content, moderation endpoint checks it, if clean store and display, if flagged queue for review.
Pattern 4: Semantic search
Index documents via embeddings, store in pgvector, query with embeddings plus cosine similarity.
FAQs
Q: Do I need a separate SDK or just the openai package?
A: Just the openai npm package (or Python equivalent). Set baseURL to https://assisters.dev/api/v1↗ in the constructor. No other changes needed for existing OpenAI integrations.
Q: What is the request timeout?
A: Standard HTTP timeouts apply. For long generation requests, set a timeout of 30–60 seconds on your HTTP client. Streaming responses begin faster than waiting for the full completion.
Q: Can I use the API in a browser (client-side)?
A: Never expose your API key in client-side JavaScript. Always call the Assisters API from server-side code (API routes, server actions, serverless functions). If you need client-side AI, proxy through your own backend.
Q: How do I handle errors?
A: The API returns standard HTTP error codes. Catch OpenAI.APIError in TypeScript or openai.APIError in Python. Common errors: 401 (invalid key), 429 (rate limit), 500 (server error). Implement exponential backoff for retries.
Q: Can I use Assisters with LangChain?
A: Yes. LangChain's OpenAI integration accepts a custom baseURL. Initialize ChatOpenAI with the Assisters base URL and your API key stored as an environment variable.
Q: Is there a webhook or async API for long-running tasks?
A: Check current API documentation at assisters.dev for async job APIs. For long-running generation tasks, streaming is the recommended approach.
Conclusion
The Assisters API is the straightforward choice for developers who want OpenAI-compatible AI infrastructure at a predictable flat cost. The drop-in SDK compatibility removes migration friction, and the breadth of endpoints (chat, embeddings, moderation, transcription, reranking) covers most standard AI app requirements from a single provider.
The limitation to plan around: for specialized tasks requiring GPT-4o's reasoning, image generation, or fine-tuning, the OpenAI API offers more advanced capabilities. For the majority of production AI app use cases, Assisters delivers at a lower and more predictable cost.
Get your API key and start building at Assisters↗ — 14-day Pro trial, cancel anytime.
Also see: [Assisters AI for Developers Review](/assisters-ai-for-developers-review) | [Assisters vs ChatGPT 2026](/assisters-vs-chatgpt-2026) | [Best AI Tools for Freelancers 2026](/best-ai-tools-for-freelancers-2026)