← Retour aux guides

Build a Chatbot Backend with an OpenAI API

What an OpenAI-Compatible Chatbot Backend Does

A chatbot backend receives a user message, sends it to a language model, and returns the model's answer to your website or mobile app. Building this layer on an OpenAI-compatible API lets you use familiar SDKs while keeping your application code independent from a single model provider.

The backend should handle more than forwarding text. It should protect API keys, maintain conversation history, select a model, enforce usage limits, manage errors, and record enough information to troubleshoot failed requests.

Why Use 59API?

59API is an AI API relay with an OpenAI-compatible interface. Its base URL is https://api.59api.com, so developers can connect through an OpenAI SDK instead of learning an entirely different integration pattern. It provides pay-as-you-go access to Claude models, including Opus, Sonnet, Haiku, and Fable, as well as GPT models.

This is useful when you want to compare model quality or match a model to a task without rewriting your chatbot. 59API is also designed as a low-cost relay, uses native official-quality models rather than downgraded substitutes, and offers a referral rebate. Always check the current model list, pricing, and request limits before deploying.

1. Create the Backend Project

Choose a server framework such as FastAPI, Express, Django, or Laravel. Create one private endpoint, such as POST /api/chat, that accepts a conversation or the latest user message. Your browser or mobile app should call this endpoint; it should never call the model API directly.

Install the official OpenAI SDK for your programming language. OpenAI-compatible services generally work by changing two values: the API key and the client base URL. Store the 59API key in an environment variable such as AI_API_KEY, and configure the SDK to use https://api.59api.com. If your SDK requires a versioned path, follow 59API's current endpoint documentation rather than guessing.

2. Send a Chat Completion Request

Build a messages array with a system instruction, previous conversation turns, and the newest user message. The system instruction should define the chatbot's role, tone, boundaries, and response style. Then send the array to the compatible chat-completions method with a selected model and a sensible output limit.

For example, your server can validate a request containing message and conversation_id, load the last several turns from a database, append the new user message, and forward the result to 59API. Return only the assistant's text and a conversation identifier to the client. Do not return your provider key, internal prompts, or unnecessary request metadata.

3. Control Conversation History

Language models do not automatically remember users between requests. Your application must store messages in a database such as PostgreSQL, MySQL, or a document store. Save the user ID, conversation ID, role, content, model, timestamps, and request status.

Limit the history sent on every request. A simple approach is to keep the system message plus the most recent turns. For longer chats, summarize older messages and store the summary separately. This reduces token usage, improves response speed, and helps control pay-as-you-go costs.

4. Add Security and Reliability

• Keep the API key in environment variables or a secret manager, never in frontend JavaScript or a public repository.
• Authenticate your own /api/chat route and apply per-user rate limits.
• Validate message length and reject empty or excessively large requests.
• Set request timeouts and retry only temporary failures, using exponential backoff.
• Log status codes, latency, model, and token usage without storing sensitive user content unnecessarily.

Also add moderation or application-specific safety rules before displaying responses. A timeout, rate limit, or provider error should produce a friendly fallback message rather than an exposed stack trace.

5. Stream Responses for a Better Experience

For longer answers, streaming lets the user see text as it is generated. Your backend can forward the compatible API's streamed events using Server-Sent Events or another supported transport. Buffer the output for storage, detect stream errors, and send a final completion event so the frontend knows when to stop its loading indicator.

Test Before Launch

Test normal questions, empty input, long conversations, simultaneous users, timeouts, and provider failures. Compare Claude and GPT models for accuracy, speed, and cost on your real prompts. Start with a small spending limit and monitor usage daily.

When you are ready, 59API is a practical low-cost place to start because your OpenAI SDK integration can remain largely unchanged while you evaluate Claude and GPT models. Sign up for 59API, create an API key, and build the first version behind your own secure backend.

Tarifs · Docs