Working with OpenAI and Anthropic APIs in Java

As an AI developer, transitioning from theoretical models to production-ready applications requires mastering API integrations. While Python is widely used in data science, Java remains the backbone of enterprise software engineering. Integrating Large Language Models (LLMs) from industry leaders like OpenAI and Anthropic into robust Java applications allows you to build scalable, secure, and highly performant AI-driven solutions.

In this guide, we will explore how to connect to OpenAI's GPT models and Anthropic's Claude models using modern Java. We will cover connection architectures, authentication, request construction, response parsing, and error handling.

The API Integration Flow

Before writing code, it is essential to understand how your Java application interacts with LLM providers. The communication follows a standard client-server model over HTTPS, utilizing RESTful endpoints and JSON payloads.

+---------------------+             HTTPS POST (JSON)             +-----------------------+
|  Java Application   | ----------------------------------------> |  LLM Provider API     |
|  - Set API Key      |                                           |  (OpenAI or Anthropic)|
|  - Build Prompt     | <---------------------------------------- |                       |
|  - Handle Timeout   |             JSON Response                 |  - Process Tokens     |
+---------------------+                                           +-----------------------+
    

Both OpenAI and Anthropic require authentication headers, specific payload formats, and proper handling of stateless request-response cycles. Every request must pass an API key, specify the target model, and provide a list of structured messages.

Setting Up Your Java Environment

To follow this guide, you need Java 11 or higher, as we will leverage the native HttpClient introduced in Java 11. This avoids external dependencies and keeps your codebase lightweight. If you are building enterprise applications, you might eventually transition to frameworks like LangChain4j, but understanding the raw HTTP layer is critical for debugging and custom integrations.

First, ensure you have your API keys stored securely as environment variables. Never hardcode your credentials inside your source code.

export OPENAI_API_KEY="your-openai-api-key-here"
export ANTHROPIC_API_KEY="your-anthropic-api-key-here"
    

Integrating the OpenAI Chat Completion API

OpenAI uses the Chat Completions endpoint for its GPT-4o and GPT-3.5 models. The request body requires a model parameter and a messages array containing roles (system, user, assistant) and content.

Java Implementation for OpenAI

Here is a complete, dependency-free Java class that sends a prompt to OpenAI and prints the response.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class OpenAIClient {
    private static final String API_URL = "https://api.openai.com/v1/chat/completions";
    private static final String API_KEY = System.getenv("OPENAI_API_KEY");

    public static void main(String[] args) {
        if (API_KEY == null || API_KEY.isEmpty()) {
            System.err.println("Error: OPENAI_API_KEY environment variable is not set.");
            return;
        }

        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        String jsonPayload = "{"
                + "\"model\": \"gpt-4o-mini\","
                + "\"messages\": ["
                + "  {\"role\": \"system\", \"content\": \"You are a helpful Java programming assistant.\"},"
                + "  {\"role\": \"user\", \"content\": \"Explain polymorphism in one sentence.\"}"
                + "],"
                + "\"temperature\": 0.7"
                + "}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + API_KEY)
                .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200) {
                System.out.println("Response from OpenAI:");
                System.out.println(response.body());
            } else {
                System.err.println("Error: HTTP " + response.statusCode());
                System.err.println(response.body());
            }
        } catch (Exception e) {
            System.err.println("Failed to send request: " + e.getMessage());
        }
    }
}
    

Integrating the Anthropic Claude API

Anthropic's Claude models (such as Claude 3.5 Sonnet) use a Messages API. While similar to OpenAI, there are critical differences in the headers and payload structure. Anthropic requires custom headers for the API key and the API version, and system prompts are passed as a top-level parameter rather than a message role.

Java Implementation for Anthropic

The following Java code demonstrates how to target the Anthropic API using native Java classes.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class AnthropicClient {
    private static final String API_URL = "https://api.anthropic.com/v1/messages";
    private static final String API_KEY = System.getenv("ANTHROPIC_API_KEY");

    public static void main(String[] args) {
        if (API_KEY == null || API_KEY.isEmpty()) {
            System.err.println("Error: ANTHROPIC_API_KEY environment variable is not set.");
            return;
        }

        HttpClient client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        String jsonPayload = "{"
                + "\"model\": \"claude-3-5-sonnet-20240620\","
                + "\"max_tokens\": 1024,"
                + "\"system\": \"You are a helpful technical writer.\","
                + "\"messages\": ["
                + "  {\"role\": \"user\", \"content\": \"Explain encapsulation in one sentence.\"}"
                + "]"
                + "}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL))
                .header("Content-Type", "application/json")
                .header("x-api-key", API_KEY)
                .header("anthropic-version", "2023-06-01")
                .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 200) {
                System.out.println("Response from Anthropic:");
                System.out.println(response.body());
            } else {
                System.err.println("Error: HTTP " + response.statusCode());
                System.err.println(response.body());
            }
        } catch (Exception e) {
            System.err.println("Failed to send request: " + e.getMessage());
        }
    }
}
    

Comparing Key Parameters

When working with these APIs, you will configure several generation parameters to control model behavior. Understanding these parameters is vital for consistent outputs:

• Temperature: Controls randomness. Values closer to 0.0 make the output deterministic and focused, while values closer to 1.0 increase creativity and variety.
• Max Tokens: Sets the limit on how many tokens the model can generate in its response. This helps control costs and prevents runaway generations.
• System Prompt: Sets the behavioral context or persona of the model. In OpenAI, this is a message with the role "system". In Anthropic, this is a top-level string parameter named "system".

Real-World Use Cases

Integrating these APIs enables several enterprise-grade features:

• Automated Customer Support: Routing customer inquiries to Claude or GPT to draft context-aware email replies or live-chat responses based on internal documentation.
• Data Extraction and Structuring: Sending messy, unstructured text (like invoices or medical logs) to the API and requesting a structured JSON output using system instructions.
• Code Review and Refactoring: Building internal developer tools that analyze Java source files for bugs, security vulnerabilities, and code-style violations.

Common Mistakes and How to Avoid Them

• Hardcoding API Keys: Never put API keys in your code. If you push your code to a public repository, bots will scrape your keys within seconds, leading to massive bills. Always use environment variables or secure vault services.
• Ignoring Rate Limits (HTTP 429): High-volume applications will hit rate limits. Always implement an exponential backoff retry mechanism in your Java code to handle 429 status codes gracefully.
• Not Specifying Timeouts: LLM APIs can sometimes experience latency. If you do not configure connection and read timeouts on your HttpClient, your application threads could hang indefinitely, leading to resource exhaustion.
• Unstructured JSON Parsing: Parsing JSON responses using manual string manipulation can lead to bugs. Use robust libraries like Jackson or Gson to deserialize the responses into strongly typed Java objects.

Interview Preparation Notes

• How do you secure API keys in an enterprise Java application? Explain that keys should be injected at runtime using environment variables, Kubernetes secrets, or cloud configuration managers like AWS Secrets Manager or HashiCorp Vault, rather than being stored in properties files.
• What is the difference between temperature and top_p? Temperature scales the logits (probabilities) before sampling, whereas top_p (nucleus sampling) limits the pool of candidate words to a cumulative probability threshold. It is recommended to alter one, but not both.
• How do you handle long-running LLM requests in a web application? Mention asynchronous processing using Java's CompletableFuture or reactive programming models to avoid blocking the main execution threads. You can also discuss streaming responses using Server-Sent Events (SSE).

Summary

Integrating OpenAI and Anthropic APIs into Java applications opens up endless possibilities for intelligent automation. By understanding the underlying HTTP requests, configuring critical generation parameters, and implementing robust security and error-handling patterns, you can build production-ready AI applications. In future topics, such as prompt engineering and semantic search, we will build upon these fundamental API integration skills to create even more sophisticated systems.