DEV Community

IronSoftware
IronSoftware

Posted on

OpenAI ChatGPT with PDFs in C# (.NET Guide)

#csharp #dotnet

AI-generated content needs a professional output format. ChatGPT produces text, but your clients want PDFs. Here's how to connect OpenAI's API to PDF generation in C#.

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

var openai = new OpenAIAPI("your-api-key");
var chat = openai.Chat.CreateConversation();

chat.AppendUserInput("Write a brief executive summary about Q4 sales trends");
var response = await chat.GetResponseFromChatbotAsync();

var html = $"<h1>Executive Summary</h1><p>{response}</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("executive-summary.pdf");
Enter fullscreen mode Exit fullscreen mode

ChatGPT writes the content. IronPDF handles the formatting and export.

Why Combine AI with PDF Generation?

The use cases are everywhere:

  • Report generation - AI summarizes data, PDF delivers it professionally
  • Document drafting - GPT writes contracts, proposals, letters
  • Content localization - Translate documents and export as PDFs
  • Data analysis - AI interprets CSV/JSON, outputs formatted reports
  • Chatbot exports - Let users download conversation summaries

AI handles the cognitive work. PDF handles the presentation.

How Do I Set Up the OpenAI Integration?

Install the required packages:

Install-Package IronPdf
Install-Package OpenAI
Enter fullscreen mode Exit fullscreen mode

Configure your API key:

using OpenAI_API;
// Install via NuGet: Install-Package OpenAI

// From environment variable (recommended)
var apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
var openai = new OpenAIAPI(apiKey);

// Or directly (not recommended for production)
var openai = new OpenAIAPI("sk-...");
Enter fullscreen mode Exit fullscreen mode

Keep API keys out of source control. Use environment variables or Azure Key Vault.

How Do I Generate a Complete Report?

Build structured documents with multiple AI-generated sections:

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

public async Task<byte[]> GenerateReport(ReportData data)
{
    var openai = new OpenAIAPI(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));

    // Generate multiple sections
    var summary = await GetAIResponse(openai,
        $"Write a 2-paragraph executive summary for: {data.Title}");

    var analysis = await GetAIResponse(openai,
        $"Analyze these metrics and identify trends: {data.MetricsJson}");

    var recommendations = await GetAIResponse(openai,
        $"Based on this data, provide 3 actionable recommendations: {data.MetricsJson}");

    var html = $@"
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 40px; }}
                h1 {{ color: #333; }}
                h2 {{ color: #666; border-bottom: 1px solid #ccc; }}
                p {{ line-height: 1.6; }}
            </style>
        </head>
        <body>
            <h1>{data.Title}</h1>
            <h2>Executive Summary</h2>
            <p>{summary}</p>

            <h2>Analysis</h2>
            <p>{analysis}</p>

            <h2>Recommendations</h2>
            <p>{recommendations}</p>
        </body>
        </html>";

    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    return pdf.BinaryData;
}

private async Task<string> GetAIResponse(OpenAIAPI openai, string prompt)
{
    var chat = openai.Chat.CreateConversation();
    chat.AppendUserInput(prompt);
    return await chat.GetResponseFromChatbotAsync();
}
Enter fullscreen mode Exit fullscreen mode

Each section is generated independently, giving you control over prompts and formatting.

How Do I Extract Text from PDFs for AI Analysis?

Send PDF content to ChatGPT for summarization or Q&A:

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

public async Task<string> SummarizePdf(string pdfPath)
{
    // Extract text from PDF
    var pdf = PdfDocument.FromFile(pdfPath);
    var text = pdf.ExtractAllText();

    // Send to ChatGPT for summarization
    var openai = new OpenAIAPI(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));
    var chat = openai.Chat.CreateConversation();

    chat.AppendUserInput($@"
        Summarize the following document in 3 bullet points:

        {text}
    ");

    return await chat.GetResponseFromChatbotAsync();
}
Enter fullscreen mode Exit fullscreen mode

For long PDFs, chunk the text to stay within token limits.

How Do I Handle Long Documents?

GPT has token limits. Split content intelligently:

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

public async Task<string> ProcessLongDocument(string pdfPath)
{
    var pdf = PdfDocument.FromFile(pdfPath);
    var fullText = pdf.ExtractAllText();

    // Split into chunks (roughly 3000 tokens ≈ 12000 characters)
    var chunks = SplitIntoChunks(fullText, 10000);
    var summaries = new List<string>();

    var openai = new OpenAIAPI(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));

    foreach (var chunk in chunks)
    {
        var chat = openai.Chat.CreateConversation();
        chat.AppendUserInput($"Summarize this section: {chunk}");
        var summary = await chat.GetResponseFromChatbotAsync();
        summaries.Add(summary);
    }

    // Combine chunk summaries into final summary
    var combinedChat = openai.Chat.CreateConversation();
    combinedChat.AppendUserInput(
        $"Combine these summaries into one cohesive summary: {string.Join("\n\n", summaries)}");

    return await combinedChat.GetResponseFromChatbotAsync();
}

private List<string> SplitIntoChunks(string text, int chunkSize)
{
    var chunks = new List<string>();
    for (int i = 0; i < text.Length; i += chunkSize)
    {
        chunks.Add(text.Substring(i, Math.Min(chunkSize, text.Length - i)));
    }
    return chunks;
}
Enter fullscreen mode Exit fullscreen mode

This "map-reduce" pattern processes each chunk, then synthesizes results.

How Do I Create a Q&A System for PDFs?

Build an interactive document assistant:

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

public class PdfAssistant
{
    private readonly string _documentText;
    private readonly OpenAIAPI _openai;

    public PdfAssistant(string pdfPath)
    {
        var pdf = PdfDocument.FromFile(pdfPath);
        _documentText = pdf.ExtractAllText();
        _openai = new OpenAIAPI(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));
    }

    public async Task<string> AskQuestion(string question)
    {
        var chat = _openai.Chat.CreateConversation();

        // Set context
        chat.AppendSystemMessage($@"
            You are a helpful assistant that answers questions about a document.
            Only answer based on the document content provided.
            If the answer isn't in the document, say so.

            Document content:
            {_documentText}
        ");

        chat.AppendUserInput(question);
        return await chat.GetResponseFromChatbotAsync();
    }
}

// Usage
var assistant = new PdfAssistant("contract.pdf");
var answer = await assistant.AskQuestion("What is the termination clause?");
Enter fullscreen mode Exit fullscreen mode

The system message grounds responses in the actual document.

How Do I Generate PDFs from Chat Conversations?

Export conversation history to PDF:

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

public class ChatExporter
{
    private readonly List<(string Role, string Content)> _messages = new();

    public void AddMessage(string role, string content)
    {
        _messages.Add((role, content));
    }

    public byte[] ExportToPdf()
    {
        var messagesHtml = string.Join("", _messages.Select(m => $@"
            <div class='{m.Role.ToLower()}'>
                <strong>{m.Role}:</strong>
                <p>{m.Content}</p>
            </div>"));

        var html = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial; margin: 30px; }}
                    .user {{ background: #e3f2fd; padding: 15px; margin: 10px 0; }}
                    .assistant {{ background: #f5f5f5; padding: 15px; margin: 10px 0; }}
                </style>
            </head>
            <body>
                <h1>Conversation Export</h1>
                <p>Generated: {DateTime.Now:g}</p>
                {messagesHtml}
            </body>
            </html>";

        var renderer = new ChromePdfRenderer();
        return renderer.RenderHtmlAsPdf(html).BinaryData;
    }
}
Enter fullscreen mode Exit fullscreen mode

Users can download their AI chat sessions as formatted documents.

How Do I Add AI-Generated Annotations?

Enhance existing PDFs with AI insights:

using IronPdf;
using OpenAI_API;
// Install via NuGet: Install-Package IronPdf
// Install via NuGet: Install-Package OpenAI

public async Task<byte[]> AddAiSummary(string pdfPath)
{
    var pdf = PdfDocument.FromFile(pdfPath);
    var text = pdf.ExtractAllText();

    // Get AI summary
    var openai = new OpenAIAPI(Environment.GetEnvironmentVariable("OPENAI_API_KEY"));
    var chat = openai.Chat.CreateConversation();
    chat.AppendUserInput($"Provide a 2-sentence summary: {text}");
    var summary = await chat.GetResponseFromChatbotAsync();

    // Add summary as first page
    var summaryHtml = $@"
        <div style='padding:40px; font-family:Arial;'>
            <h2>AI-Generated Summary</h2>
            <p style='font-style:italic;'>{summary}</p>
            <hr>
            <small>Generated by OpenAI on {DateTime.Now:d}</small>
        </div>";

    var renderer = new ChromePdfRenderer();
    var summaryPdf = renderer.RenderHtmlAsPdf(summaryHtml);

    // Merge summary with original
    var combined = PdfDocument.Merge(summaryPdf, pdf);
    return combined.BinaryData;
}
Enter fullscreen mode Exit fullscreen mode

The AI summary becomes a cover page for the original document.

What About Costs and Rate Limits?

OpenAI charges per token. Monitor usage:

using OpenAI_API;
// Install via NuGet: Install-Package OpenAI

// Estimate tokens before sending (rough: 1 token ≈ 4 chars)
int estimatedTokens = text.Length / 4;

if (estimatedTokens > 4000)
{
    // Chunk the text or use a cheaper model
    Console.WriteLine($"Warning: ~{estimatedTokens} tokens, consider chunking");
}
Enter fullscreen mode Exit fullscreen mode

For high-volume applications:

  • Use GPT-3.5-turbo for simple tasks (cheaper)
  • Cache responses for identical queries
  • Implement request queuing for rate limits

AI plus PDF generation opens new automation possibilities. Let GPT handle the thinking, IronPDF handle the presentation.

For more AI integration examples, see the IronPDF OpenAI documentation.

Written by Jacob Mellor, CTO at Iron Software. Jacob created IronPDF and leads a team of 50+ engineers building .NET document processing libraries.

Top comments (0)