Using OpenAI APIs: Basic chat completions API Guide in .NET

Imagine you're building a smart home system. Just as your system needs to communicate with various devices through specific protocols, developers need to interact with AI models through APIs. OpenAI's APIs serve as this communication bridge, allowing you to harness the power of advanced AI models like GPT-4 in your applications.

Imagine if you could add the magic of ChatGPT, DALL-E, or Whisper to your own apps—instantly making them smarter, more creative, and more helpful. That’s exactly what OpenAI APIs let you do! These are powerful, easy-to-use web services that unlock the same AI superpowers behind the tools everyone’s talking about.

What can you build? Here are just a few real-world examples:

• Write emails for you: Let your app draft a friendly reply or summarize a long thread in seconds.
• Chatbots that feel human: Add a virtual assistant to your website that can answer questions, help with shopping, or even tell jokes.
• Turn sketches into art: Use DALL-E to generate stunning images from a simple description—"a cat surfing a wave at sunset" becomes a real picture!
• Transcribe meetings automatically: Whisper can listen to audio and give you a written transcript, perfect for notes or accessibility.
• Personalized learning: Build a study buddy that explains tough concepts in plain language, tailored to each student.

With OpenAI APIs, you’re not just coding—you’re inventing the future. Whether you want to automate boring tasks, create something fun, or solve real problems, these APIs are your gateway to next-level innovation. The possibilities are endless and limited only by your imagination!

Wondering when OpenAI APIs can make a real difference? Here are some moments where they shine—and you’ll probably recognize a few from your own life or work:

• Stuck on a blank page? Instantly generate blog intros, catchy headlines, or even code snippets to kickstart your creativity.
• Customer support overload? Deploy a chatbot that answers FAQs, helps users troubleshoot, or even cracks a joke to lighten the mood.
• Need to summarize mountains of info? Let AI read through long articles, meeting notes, or emails and give you the highlights in seconds.
• Dreaming up new designs? Use AI to brainstorm product ideas, generate marketing copy, or even create images for your next campaign.
• Making your app accessible? Transcribe audio, translate languages, or simplify complex text so everyone can use your product.
• Personalized learning or coaching? Build a tutor that adapts to each student’s needs, explains tough concepts, or quizzes them in a fun way.

If you’ve ever wished for a superpower to automate, accelerate, or amplify your work—OpenAI APIs are your toolkit. The best part? You don’t need to be an AI expert to get started!

1. Authentication: Getting and Securing Your API Key

Authentication is required for every OpenAI API call. You must use a secret API key, which you can generate from your OpenAI dashboard.

• Never share or commit your API key to source control.
• Store your API key in a secure location, such as an environment variable or a secrets manager.
• For local development, you can set the key in your shell profile or appsettings.Development.json (but never in public repos).

Example: Setting an environment variable in your terminal (macOS/Linux):

export OPENAI_API_KEY=sk-...yourkey...

Or in Windows PowerShell:

$env:OPENAI_API_KEY="sk-...yourkey..."

Accessing the key in C#:

string apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
if (string.IsNullOrWhiteSpace(apiKey))
    throw new InvalidOperationException("OpenAI API key not found in environment variables.");
        

2. Setup: Creating a Typed API Client

To call OpenAI APIs directly, you'll use HttpClient to make HTTP requests. Here is a simple client class that includes authentication in every request:

public class OpenAIClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;

    public OpenAIClient(HttpClient httpClient, string apiKey)
    {
        _httpClient = httpClient;
        _apiKey = apiKey;
    }

    private HttpRequestMessage CreateRequest(string url, HttpMethod method, string jsonContent)
    {
        var request = new HttpRequestMessage(method, url);
        request.Headers.Add("Authorization", $"Bearer {_apiKey}");
        request.Content = new StringContent(jsonContent, System.Text.Encoding.UTF8, "application/json");
        return request;
    }
}
        

3. Handling Chat Conversations (Chat Completion API)

To have a conversation with an AI model—such as asking it to summarize a movie—you'll use the Chat Completions endpoint. This endpoint lets you send a series of messages (like a chat history) and receive a smart, context-aware response from the model. The request body for this endpoint typically includes:

• model: The name of the AI model you want to use (e.g., gpt-4 or gpt-3.5-turbo). Different models have different capabilities and costs.
• messages: An array of message objects representing the conversation so far. Each message has a role (such as system, user, or assistant) and content (the actual text). This structure allows the model to understand context and respond appropriately.
• max_tokens: The maximum number of tokens (words or word pieces) in the response. This helps control the length and cost of the output.
• Other optional parameters: You can also specify things like temperature (controls randomness/creativity), top_p (controls diversity), and more, depending on your needs.

Example prompt: Give me a summary of the movie Inception.

public async Task<string> GetChatResponseAsync()
{
    var url = "https://api.openai.com/v1/chat/completions";
    var requestBody = new
    {
        model = "gpt-4",
        messages = new[]
        {
            new { role = "system", content = "You are a helpful assistant." },
            new { role = "user", content = "Give me a summary of the movie Inception." }
        },
        max_tokens = 150
    };
    var json = JsonSerializer.Serialize(requestBody);
    var request = CreateRequest(url, HttpMethod.Post, json);

    var response = await _httpClient.SendAsync(request);
    response.EnsureSuccessStatusCode();

    var responseString = await response.Content.ReadAsStringAsync();
    using var doc = JsonDocument.Parse(responseString);
    return doc.RootElement.GetProperty("choices")[0].GetProperty("message").GetProperty("content").GetString();
}
// Usage:
// string summary = await GetChatResponseAsync();
        

How to use this demo: Enter your personal OpenAI API key (you can create one from your OpenAI dashboard) in the first field. Then, type the name of any movie you want summarized in the second field. Click Get Summary and the AI will generate a short summary of the movie using OpenAI's API. Your API key is never stored or sent anywhere except directly to OpenAI for this request.

• Never hardcode your API key! Treat it like your password—use environment variables or a secure vault. One accidental push to GitHub can expose your account.
• Expect the unexpected. Always handle errors gracefully. Network hiccups, expired keys, or API changes can happen—show helpful messages, not cryptic errors.
• Watch your usage and costs. OpenAI APIs are powerful, but not free. Set usage limits, monitor your dashboard, and consider caching frequent responses to save money.
• Respect rate limits. If you send too many requests too quickly, you’ll get throttled. Build in retries with backoff and inform users if things slow down.
• Mind the tokens. Each model has a token (word) limit. If your prompt or response is too long, you’ll get errors or cut-off answers. Trim and test your prompts!
• Stay up to date. OpenAI is evolving fast. Check the docs for new features, models, and best practices—what’s true today might change tomorrow.
• Be ethical and transparent. Let users know when they’re interacting with AI, and never use generated content to mislead or harm.

Pro tip: The best AI apps feel magical because they combine smart tech with thoughtful design. Test with real users, handle edge cases, and always keep learning!