← Volver a las guías

Go, Rust and Java LLM APIs: A Practical Fix-It Guide

Start with one request that every language can reproduce

Connecting Go, Rust or Java to an LLM API usually fails for ordinary HTTP reasons: an incorrect URL, missing authentication, an unsupported model identifier or a timeout. Start with a non-streaming request before adding SDK abstractions, conversation history or tools.

59API provides pay-as-you-go access to Claude and GPT models through an API relay. Its API base is https://api.59api.com. For an OpenAI-compatible Chat Completions request, use the documented versioned route, typically /v1/chat/completions. Confirm the complete endpoint in the current documentation rather than assuming every API uses the same path.

• Read your key from an environment variable such as LLM_API_KEY; never commit it.
• Send Authorization: Bearer YOUR_KEY and Content-Type: application/json.
• Use a model identifier listed in your account, not a guessed display name.
• Start with this payload, replacing the model value: {"model":"YOUR_MODEL_ID","messages":[{"role":"user","content":"Reply with OK"}],"stream":false}.

Go: why does the request hang or leak connections?

For direct HTTP integration, Go's standard library is sufficient. Create a reusable http.Client with an explicit timeout; the default client has no overall request timeout. A practical initial setting is Timeout: 120 * time.Second, adjusted to your workload.

Build the POST with http.NewRequestWithContext and a JSON body produced by json.Marshal. Set both headers explicitly. After client.Do, check the error before accessing the response, then defer resp.Body.Close(). Inspect the HTTP status before decoding a successful response. A JSON error body is not a completion.

If you use an OpenAI Go SDK instead, configure its API key and base URL explicitly. Check whether it expects a base ending in /v1/; otherwise, duplicated version paths can produce 404 errors.

Rust: why is an HTTP error being treated as success?

Use a reusable reqwest::Client with a timeout. For a typical asynchronous application, enable reqwest's json feature and configure a Tokio runtime. Use serde_json::json! to construct the payload.

The request chain is: client.post(endpoint).bearer_auth(key).json(&payload).send().await?. Importantly, send() can succeed even when the server returns 401 or 429. Capture response.status(), then read the body once and branch on the status. Calling text() consumes the response; you cannot subsequently call json() on that same value.

Java: which HTTP client and timeout should I use?

Java 11 and later include java.net.http.HttpClient. Reuse a client configured with connectTimeout(Duration.ofSeconds(10)), and set a separate request timeout using HttpRequest.Builder.timeout. Connection timeout alone does not limit the full inference request.

Build the request with POST(HttpRequest.BodyPublishers.ofString(json)) and the authentication and content-type headers. Send it with HttpResponse.BodyHandlers.ofString(), then inspect statusCode() before parsing body(). Use Jackson or another JSON library instead of concatenating user input into JSON strings.

FAQ: what do common API failures mean?

• 401 or 403? Check the key, account permissions and authentication format. An environment variable containing an accidental newline can break authentication.
• 404? Inspect the final URL and response body. Common causes include a missing or duplicated /v1 segment, an unsupported route or an unavailable model.
• 400? Reduce the request to the minimal payload. Tool schemas, token-limit fields and other parameters are not interchangeable across every model.
• 429 or 5xx? Use bounded exponential backoff with jitter and honor Retry-After when present. Do not repeatedly retry authentication or validation failures.
• Timeout after sending? The request may already have been processed. Retrying can create another generation and additional charges; do not assume retries are free or idempotent.

FAQ: how do streaming and Claude compatibility differ?

OpenAI-compatible streaming commonly uses server-sent events, not one JSON document. Parse complete events across arbitrary network chunks. Go scanners need an appropriate buffer limit; Rust needs streaming support; Java can consume an input stream incrementally.

59API supports OpenAI SDKs, Claude Code and Codex, but compatibility does not make every protocol identical. Follow each client's endpoint and authentication configuration, especially for native Claude requests.

Keep costs predictable

59API is positioned among the lowest-cost relays, offering native, official-quality models without downgrading, plus a referral rebate. Compare current per-model prices, trim repeated context and set supported output limits. If that fits your workload, sign up and test a small prepaid budget before scaling.

Precios · Docs