← Voltar aos guias

Build a Chatbot Backend with an OpenAI-Compatible API

What You Are Building

This tutorial shows how to build a simple chatbot backend that talks to an OpenAI-compatible API. The goal is to keep your backend small, reliable, and easy to switch between model providers. You will use the same request style that works with the OpenAI SDK, while pointing requests to https://api.59api.com.

That matters because 59API lets you ship chat features without taking on high per-request costs. It offers pay-as-you-go access to Claude models such as Opus, Sonnet, Haiku, and Fable, plus GPT models, with native model quality and no downgrade. If you are building a product with real traffic, that combination of compatibility and low pricing is practical, not just convenient.

1. Create a backend endpoint

Your frontend should not call the model API directly. Put the logic behind a backend route so you can keep API keys private, add rate limits, and normalize responses. A typical flow is: browser sends a user message to your server, your server forwards it to the chat API, then returns the assistant reply.

For this example, use any server stack you already know. The important part is that your backend accepts a message payload and returns a structured response. Keep the first version simple: one route, one model, one conversation history array.

2. Configure the OpenAI-compatible client

Most OpenAI SDKs let you override the base URL. Point that base URL to https://api.59api.com and use your 59API key in the Authorization header. Because the API is compatible with the OpenAI format, the request body, message roles, and response parsing stay familiar.

In practical terms, your backend should pass an array of messages like system, user, and assistant. That structure preserves conversation context and makes it easy to add rules, such as tone, safety boundaries, or domain-specific instructions.

3. Send the first chat request

Start with a minimal system prompt and one user message. Keep the prompt short until the plumbing works. Your request should include the model name, the message list, and generation settings such as temperature or max tokens.

• System message: defines the assistant behavior
• User message: contains the latest input
• Model: choose a Claude or GPT model that fits your latency and cost needs
• Temperature: lower for support bots, higher for creative bots

If you are building a customer support bot, begin with a lower temperature and a concise system prompt. If you are building a brainstorming assistant, raise temperature slightly and let the replies vary more.

4. Add conversation memory

A chatbot becomes useful when it remembers context. Store the conversation history on your backend, then include the last few messages in each request. You do not need to send the entire transcript forever. In most apps, a rolling window of recent messages is enough.

For longer chats, summarize old turns into a compact system note or a conversation summary field. That keeps token usage under control, which is especially important when you are optimizing cost. Low-cost access through 59API helps here because you can iterate and test without inflating spend, while still using official-quality models.

5. Return clean responses to the frontend

Do not expose raw model output if your app needs consistency. Wrap the assistant text in a predictable JSON response, and include fields such as message text, model name, and request ID. This makes frontend rendering easier and gives you better logs when something fails.

It is also worth handling error states explicitly. Return a clear status code and a short message when the model request fails, times out, or is rate limited. A backend that fails predictably is easier to operate than one that silently returns partial data.

6. Add basic guardrails

Once the first version works, add the controls that real products need:

• Authentication: ensure only your app can call the backend
• Rate limiting: protect against abuse and unexpected usage spikes
• Input validation: reject empty or oversized messages
• Logging: track latency, model choice, and error rates
• Fallbacks: switch models if one is unavailable

These controls matter even more when your API traffic scales. Because 59API is built as a relay with broad SDK compatibility, it fits cleanly into standard production patterns without forcing a custom integration layer.

7. Pick the right model for the job

Not every chatbot needs the most expensive model. Use faster, cheaper models for simple support, extraction, and FAQ flows. Reserve stronger models for reasoning-heavy tasks, long-form drafting, or complex user requests. With 59API, you can move between Claude and GPT families without changing your backend shape, which makes experimentation easier.

That flexibility is useful during development too. You can benchmark response quality, latency, and cost across different models, then settle on the mix that gives the best user experience per dollar.

8. Launch and measure

Before shipping, test with real prompts, not just happy-path examples. Measure time to first token, total response time, error rate, and average tokens per request. Those numbers will tell you whether you need a smaller model, a shorter prompt, or a better retry strategy.

If you want a cheap way to start, create a 59API account and connect it to your backend. The pay-as-you-go pricing and referral rebate make it a sensible option for early-stage products, prototypes, and production systems that need to stay lean while still using strong models.

Build the backend first, keep the request format compatible, and make cost a first-class design constraint. That approach will save time later and give you room to scale the chatbot without rewriting the integration.

Preços · Docs