How to Set Custom Headers and Endpoint for Using PezzoAI Proxy with OpenAI’s Official C# SDK

When integrating OpenAI’s C# SDK into your applications, you may need to use a proxy like PezzoAI for better prompt management, logging, and tracking. However, OpenAI’s official .NET SDK does not natively support dynamic proxies or custom headers. In this guide, we’ll explore how to set a custom endpoint and inject required headers dynamically to use PezzoAI effectively.

By the end of this post, you will:

• Understand how to configure OpenAI’s .NET SDK with PezzoAI.
• Learn to inject custom headers required for PezzoAI authorization.
• Implement a fallback mechanism to OpenAI’s default API in case PezzoAI fails.
• Optimize performance using cached prompts to reduce unnecessary API calls.
• See a working C# console application demonstrating these concepts.

Understanding PezzoAI Proxy & API Key Management

Why Use a Proxy Like PezzoAI?

PezzoAI helps in centralized prompt management, tracking requests, and enforcing authorization via headers. Unlike direct OpenAI API calls, PezzoAI requires:

• X-Pezzo-Api-Key – For authentication.
• X-Pezzo-Project-Id – To track requests under a specific project.
• X-Pezzo-Environment – To distinguish between development, staging, and production environments.

API Key & Organization Management in C#

The OrganizationKeysManager class is used globally through dependency injection. Each organization can have multiple API keys, one per category of task.

• If an endpoint is not provided, it defaults to OpenAI’s original endpoint.
• If PezzoAI fails, a fallback mechanism redirects the request to OpenAI.
• Prompt responses are cached to improve performance.

Setting Up OpenAI .NET SDK with PezzoAI Proxy

Step 1: Install OpenAI .NET SDK

You need to install the OpenAI .NET package. Run the following command in your terminal:

dotnet add package OpenAI --version 2.0.0-beta.11

Step 2: Configure OrganizationKeysManager to Handle API Keys and Proxies

Here’s how we manage API keys and proxy settings dynamically:

public static OpenAIClient GetOpenAIclient(int orgId, string username, KeyTypeEnum keytype, KeySybTypeEnum subtype)
{
    var key = OrganizationKeysManager.GetKey(orgId, username, keytype, subtype);
    if (key == null || string.IsNullOrWhiteSpace(key.APIKey))
    {
        throw new Exception("API key for this organization/type is not set.");
    }
    else
    {
        var openAIClientOptions = new OpenAIClientOptions();
        if (!string.IsNullOrWhiteSpace(key.Endpoint))
        {
            openAIClientOptions.Endpoint = new Uri(key.Endpoint);
            openAIClientOptions.AddPolicy(CreateAddPezzoHeaderPolicy(), PipelinePosition.PerCall);
        }
        return new OpenAIClient(key.APIKey, openAIClientOptions);
    }
}

Step 3: Inject PezzoAI Headers Dynamically

The following policy ensures that all required PezzoAI headers are set before sending requests.

private static PipelinePolicy CreateAddPezzoHeaderPolicy()
{
    return new PezzoPipelinePolicy((message) =>
    {
        message.Request.Headers.Set("X-Pezzo-Api-Key", "pez_4bc0000");
        message.Request.Headers.Set("X-Pezzo-Project-Id", "cm2g710000");
        message.Request.Headers.Set("X-Pezzo-Environment", "Production");
    });
}

Implementing the PezzoPipelinePolicy Class

The PezzoPipelinePolicy class allows us to pass custom headers dynamically by processing each request before it is sent.

internal partial class PezzoPipelinePolicy : PipelinePolicy
{
    private Action<PipelineMessage> _processMessageAction;

    public PezzoPipelinePolicy(Action<PipelineMessage> processMessageAction)
    {
        _processMessageAction = processMessageAction;
    }

    public override void Process(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
    {
        _processMessageAction(message);
        if (currentIndex < pipeline.Count - 1)
        {
            pipeline[currentIndex + 1].Process(message, pipeline, currentIndex + 1);
        }
    }

    public override async ValueTask ProcessAsync(PipelineMessage message, IReadOnlyList<PipelinePolicy> pipeline, int currentIndex)
    {
        _processMessageAction(message);
        if (currentIndex < pipeline.Count - 1)
        {
            await pipeline[currentIndex + 1].ProcessAsync(message, pipeline, currentIndex + 1);
        }
    }
}

Step 4: Implementing a Fallback Mechanism to OpenAI

If PezzoAI fails, we send the request directly to OpenAI’s endpoint.

try
{
    var client = GetOpenAIclient(orgId: 48, username: null, KeyTypeEnum.AI, KeySybTypeEnum.Generic);
    var response = await client.ChatCompletions.CreateAsync("Hello from PezzoAI!");
    Console.WriteLine(response.Choices[0].Message.Content);
}
catch (Exception ex)
{
    Console.WriteLine("PezzoAI failed. Falling back to OpenAI...");
    var fallbackClient = new OpenAIClient("your-openai-api-key");
    var fallbackResponse = await fallbackClient.ChatCompletions.CreateAsync("Hello from OpenAI!");
    Console.WriteLine(fallbackResponse.Choices[0].Message.Content);
}

Optimizing Performance: Caching PezzoAI Prompts

Caching prompts helps in reducing roundtrips to PezzoAI, improving response time and efficiency.

private static Dictionary<string, string> promptCache = new Dictionary<string, string>();

public static async Task<string> GetChatResponseAsync(string prompt, OpenAIClient client)
{
    if (promptCache.TryGetValue(prompt, out string cachedResponse))
    {
        return cachedResponse;
    }
    var response = await client.ChatCompletions.CreateAsync(prompt);
    promptCache[prompt] = response.Choices[0].Message.Content;
    return response.Choices[0].Message.Content;
}

Running the C# Console Application

Create a simple C# console application to test the implementation:

static async Task Main(string[] args)
{
    var client = GetOpenAIclient(orgId: 48, username: null, KeyTypeEnum.AI, KeySybTypeEnum.Generic);
    string prompt = "What is OpenAI?";
    string response = await GetChatResponseAsync(prompt, client);
    Console.WriteLine(response);
}

Run the program, and it will:

1. Send the request to PezzoAI proxy.
2. If PezzoAI is down, it falls back to OpenAI.
3. Cache responses to avoid redundant API calls.

Conclusion

By integrating PezzoAI with OpenAI’s .NET SDK, we achieve: ✅ Centralized API key management per organization.
✅ Dynamic proxy configuration with fallback to OpenAI.
✅ Custom header injection for PezzoAI authorization.
✅ Performance optimization using prompt caching.

Full working console app is available in this GitHub Repo.

Happy coding!

amitm

Amit Mittal is a seasoned tech entrepreneur and software developer specializing in SaaS, web hosting, and cloud solutions. As the founder of Bitss Techniques, he brings over 15 years of experience in delivering robust digital solutions, including CMS development, custom plugins, and enterprise-grade services for the education and e-commerce sectors.