← Voltar aos guias

Go, Rust and Java LLM APIs: Fix Common Failures

Using LLM APIs from Go, Rust and Java starts with an HTTPS request, but reliable integrations need careful handling of authentication, response bodies, streaming and retries. This troubleshooting guide covers practical checks for each language and explains how to keep costs predictable with 59API.

Start with one minimal request

59API provides low-cost, pay-as-you-go access to multiple model families through an OpenAI-compatible interface. Its API base URL is https://api.59api.com. For a standard Chat Completions integration, configure the API root as https://api.59api.com/v1 and send POST requests to /chat/completions. Check the endpoint configuration in your account before deployment, especially if your client appends /v1 automatically.

Send Authorization: Bearer YOUR_API_KEY and Content-Type: application/json. Begin with streaming disabled and a short message. The request body should contain a model identifier and a messages array, with each message containing role and content fields.

For example, you might choose DeepSeek V4 Flash or GPT-6 Astra. Copy the exact API model identifier from the available model listing or dashboard; a display name does not necessarily equal the value accepted in the model field.

Why am I getting 401, 403 or 404?

• 401: Check that the key is present, has no surrounding whitespace and appears in the Authorization header with the Bearer prefix.
• 403: Inspect the error body for account restrictions or model access requirements.
• 404: Check the complete request URL and model identifier. A duplicated /v1 segment or unsupported route can cause failure.

Log the status code, request duration and any returned request ID. Keep API keys and sensitive prompts out of logs. Always inspect the error body before attempting to decode a successful completion.

Go: fix empty responses and connection problems

Use net/http with a shared http.Client. Build requests with http.NewRequestWithContext so cancellation propagates when the caller disconnects or a deadline expires. Encode payloads with encoding/json rather than constructing JSON through string concatenation.

After client.Do returns successfully, defer resp.Body.Close(). Read and inspect non-2xx responses explicitly: Go does not treat an HTTP 429 or 500 as a transport error. For ordinary JSON responses, decode the body and check that choices contains an entry before accessing choices[0].message.content.

Set a timeout appropriate to the workload. A short timeout suitable for a small REST lookup may terminate a longer model response. For streaming, combine request cancellation with suitable connection and response-header timeouts.

Rust: fix serialization and async failures

With reqwest, enable the json feature and use a reusable reqwest::Client. Build the payload with serde_json::json! or typed Serialize structs. In an async application, await the request inside the configured runtime; avoid blocking network calls on runtime worker threads.

Capture response.status() before consuming the body. Reading response.text().await consumes the response, so preserve that text if you need both diagnostic logging and later JSON parsing. Check the status before deserializing into your success type, since error objects usually have a different schema.

Java: fix HTTP and JSON handling

On Java 11 or later, reuse java.net.http.HttpClient. Build the request with HttpRequest, set both required headers and serialize the payload with Jackson or another JSON library. HttpClient handles HTTP transport; it does not provide a general JSON object mapper.

Use BodyHandlers.ofString() for the initial non-streaming test, then inspect statusCode() before parsing body(). Configure a connection timeout on the client and a request timeout on the request. When handling InterruptedException, restore the thread's interrupt flag so application cancellation remains effective.

Why does streaming fail when normal requests work?

OpenAI-style streaming commonly uses server-sent events. Network chunks do not necessarily match event boundaries. Buffer incoming bytes, assemble complete events and parse their data fields. Handle the terminal [DONE] marker separately from JSON. Read incremental text from delta fields rather than expecting a complete message in every event.

Should I retry, and how do I control costs?

Retry transient connection failures, rate limits and suitable server errors with capped exponential backoff and jitter. Honor Retry-After when supplied. Avoid automatically retrying authentication errors or invalid payloads. Retrying after a partial response can generate duplicate work and additional charges.

59API combines competitive relay pricing with native official-quality models without downgrades, making it useful for comparing models behind one integration. Track token usage, limit concurrent requests and set output limits supported by your chosen endpoint. Sign up for 59API to test a small workload, compare actual costs and explore its referral rebate.

Preços · Docs