Convert Documents to Images API: Complete Tutorial & Best Practices

Ever needed to display documents in your web application without requiring users to download special viewers? Or maybe you want to create thumbnails, implement document previews, or ensure your content displays consistently across all devices? Converting documents to images solves all these challenges elegantly.

In this comprehensive guide, you’ll learn how to transform any document into high-quality JPG and PNG images using the GroupDocs.Viewer Cloud API. We’ll cover everything from basic conversion to advanced optimization techniques, complete with real-world examples and troubleshooting tips.

Why Convert Documents to Images? (The Problem You’re Solving)

Before diving into the technical details, let’s understand why document-to-image conversion is such a powerful solution:

Universal Compatibility: Images work everywhere – no special plugins, no compatibility issues, no “this file format isn’t supported” headaches. Whether your users are on mobile devices, tablets, or desktops, JPG and PNG images just work.

Consistent Display: Ever had a document look different on different devices? Images eliminate this problem entirely. What you see is exactly what your users get, every time.

Enhanced Security: When you convert sensitive documents to images, you’re creating a static snapshot that can’t be easily edited or manipulated. This is perfect for contracts, invoices, or any document where integrity matters.

Performance Benefits: Images load faster than complex document formats and don’t require client-side processing. Your users get instant previews without waiting for document readers to initialize.

Simple Integration: Adding image display to your application is straightforward – just use standard HTML <img> tags. No complex document viewers or third-party libraries required.

What File Formats Can You Convert?

The GroupDocs.Viewer Cloud API supports over 170 document formats, including:

  • Office Documents: Word (.docx, .doc), Excel (.xlsx, .xls), PowerPoint (.pptx, .ppt)
  • PDFs: All PDF versions, including password-protected files
  • Images: TIFF, BMP, GIF (for format conversion or resizing)
  • CAD Files: AutoCAD (.dwg, .dxf), and other technical drawings
  • Email Files: Outlook (.msg, .eml) and other email formats
  • Archive Files: ZIP, RAR, TAR, and more
  • Web Files: HTML, MHTML, and web archive formats

This means you can build a unified document preview system that handles virtually any file type your users might upload.

Learning Objectives

By the end of this tutorial, you’ll be able to:

  • Convert any supported document to JPG or PNG format
  • Optimize image quality and file size for your specific needs
  • Handle batch conversions efficiently
  • Implement image rendering in real applications
  • Troubleshoot common issues and optimize performance
  • Create interactive image galleries for document viewing

Prerequisites and Setup

Before we start converting documents, make sure you have:

  • GroupDocs.Viewer Cloud Account: Get your free trial here (no credit card required)
  • API Credentials: Your Client ID and Client Secret from the dashboard
  • Basic API Knowledge: Understanding of REST APIs and HTTP requests
  • Development Environment: Any programming language (we’ll show examples in multiple languages)
  • Test Document: We’ll use a sample DOCX file, but you can use any supported format

The setup process is straightforward – the free trial gives you 150 conversion operations per month, which is perfect for testing and small projects.

Step 1: Upload Your Document to Cloud Storage

The first step in any conversion is getting your document into the cloud storage. Think of this as uploading a file to a shared folder – once it’s there, you can reference it in all your API calls.

Here’s how to upload a document using a simple curl command:

# First get JSON Web Token
curl -v "https://api.groupdocs.cloud/connect/token" \
-X POST \
-d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET" \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Accept: application/json"

# Store JWT in a variable for reuse
JWT="YOUR_JWT_TOKEN"

# Upload file to storage
curl -v "https://api.groupdocs.cloud/v2.0/viewer/storage/file/SampleFiles/sample.docx" \
-X PUT \
-H "Content-Type: multipart/form-data" \
-H "Accept: application/json" \
-H "Authorization: Bearer $JWT" \
--data-binary "@/path/to/your/sample.docx"

What’s happening here? The first curl command authenticates you and gets a JWT token (think of it as a temporary password). The second command uploads your file to a specific path in the cloud storage. The file path SampleFiles/sample.docx becomes your reference for all future operations.

Pro tip: Organize your files in folders (like SampleFiles/) from the start. This makes it easier to manage multiple documents and keeps your storage organized.

Step 2: Convert Your Document to JPG Images

Now comes the exciting part – actually converting your document to images! This single API call will transform every page of your document into a separate JPG image.

curl -v "https://api.groupdocs.cloud/v2.0/viewer/view" \
-X POST \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Authorization: Bearer $JWT" \
-d "{
   'FileInfo': {
         'FilePath': 'SampleFiles/sample.docx'
      },
   'ViewFormat': 'JPG'
}"

What makes this powerful? The API automatically handles all the complex document parsing, page separation, and image generation. You don’t need to worry about font rendering, layout calculations, or format-specific quirks.

Understanding the API Response

When your document is successfully converted, you’ll receive a JSON response like this:

{
  "pages": [
    {
      "number": 1,
      "resources": null,
      "path": "viewer/sample_docx/sample_page_1.jpg",
      "downloadUrl": "https://api.groupdocs.cloud/v2.0/viewer/storage/file/viewer/sample_docx/sample_page_1.jpg"
    },
    {
      "number": 2,
      "resources": null,
      "path": "viewer/sample_docx/sample_page_2.jpg",
      "downloadUrl": "https://api.groupdocs.cloud/v2.0/viewer/storage/file/viewer/sample_docx/sample_page_2.jpg"
    },
    {
      "number": 3,
      "resources": null,
      "path": "viewer/sample_docx/sample_page_3.jpg",
      "downloadUrl": "https://api.groupdocs.cloud/v2.0/viewer/storage/file/viewer/sample_docx/sample_page_3.jpg"
    }
  ],
  "attachments": [],
  "file": null
}

Key points about the response:

  • Each page becomes a separate image file
  • The downloadUrl provides direct access to each image
  • File paths are automatically generated based on your original filename
  • Page numbers start from 1 (not 0)

This structure makes it easy to build page-by-page navigation in your application.

Step 3: Download and Use Your Image Files

Once your document is converted, you can download each page individually or programmatically fetch all images:

curl -v "https://api.groupdocs.cloud/v2.0/viewer/storage/file/viewer/sample_docx/sample_page_1.jpg" \
-X GET \
-H "Authorization: Bearer $JWT" \
--output "page1.jpg"

Real-world usage tip: In production applications, you’d typically download these images to your own server or CDN for faster access. The cloud storage is great for processing, but serving images from your own infrastructure reduces latency.

Step 4: Converting to PNG Format (When and Why)

While JPG is perfect for most document conversions, there are times when PNG is the better choice:

  • When you need transparency: PNG supports transparent backgrounds, useful for logos or documents with transparent elements
  • For text-heavy documents: PNG’s lossless compression often produces better text clarity
  • When file size isn’t critical: PNG files are typically larger but offer perfect quality

Converting to PNG is simple – just change the ViewFormat parameter:

curl -v "https://api.groupdocs.cloud/v2.0/viewer/view" \
-X POST \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Authorization: Bearer $JWT" \
-d "{
   'FileInfo': {
         'FilePath': 'SampleFiles/sample.docx'
      },
   'ViewFormat': 'PNG'
}"

Decision guide: Use JPG for photos and colorful documents where small file sizes matter. Use PNG for documents with text, logos, or when you need perfect quality reproduction.

Step 5: Optimizing Image Quality and Performance

This is where the real power of the API shines – you can fine-tune the output to meet your specific requirements.

Balancing Quality vs. File Size

For JPG images, you can control quality from 1 (smallest file, lowest quality) to 100 (largest file, highest quality):

curl -v "https://api.groupdocs.cloud/v2.0/viewer/view" \
-X POST \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Authorization: Bearer $JWT" \
-d "{
  'FileInfo': {
    'FilePath': 'SampleFiles/sample.docx'
  },
  'ViewFormat': 'JPG',
  'RenderOptions': {
     'JpegQuality': 75
  }
}"

Quality recommendations:

  • 90-100: Perfect for printing or archival purposes
  • 75-89: Excellent for web display, good balance of quality and size
  • 60-74: Good for thumbnails or preview images
  • Below 60: Only for very small thumbnails or when file size is critical

Controlling Image Dimensions

You can specify exact pixel dimensions for your output images:

curl -v "https://api.groupdocs.cloud/v2.0/viewer/view" \
-X POST \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Authorization: Bearer $JWT" \
-d "{
  'FileInfo': {
    'FilePath': 'SampleFiles/sample.docx'
  },
  'ViewFormat': 'JPG',
  'RenderOptions': {
     'Width': 800,
     'Height': 1000
  }
}"

Dimension strategy: The API maintains aspect ratio by default. If you specify both width and height, the image will be scaled to fit within those dimensions while preserving the original proportions.

Step 6: Real-World Implementation Examples

Let’s see how to implement document-to-image conversion in actual applications using the official SDKs.

C# Implementation with Error Handling

This example shows a complete C# implementation with proper error handling and file management:

using GroupDocs.Viewer.Cloud.Sdk.Api;
using GroupDocs.Viewer.Cloud.Sdk.Client;
using GroupDocs.Viewer.Cloud.Sdk.Model;
using GroupDocs.Viewer.Cloud.Sdk.Model.Requests;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;

namespace GroupDocs.Viewer.Cloud.Tutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            // Get your client ID and client secret from https://dashboard.groupdocs.cloud/
            string MyClientId = "YOUR_CLIENT_ID";
            string MyClientSecret = "YOUR_CLIENT_SECRET";

            // Create API instance
            var configuration = new Configuration(MyClientId, MyClientSecret);
            var apiInstance = new ViewApi(configuration);

            // Define rendering options
            var viewOptions = new ViewOptions
            {
                FileInfo = new FileInfo
                {
                    FilePath = "SampleFiles/sample.docx"
                },
                ViewFormat = ViewOptions.ViewFormatEnum.JPG,
                RenderOptions = new ImageOptions
                {
                    JpegQuality = 90,
                    Width = 800,
                    Height = 1000
                }
            };

            try
            {
                // Call the API to render the document
                var response = apiInstance.CreateView(new CreateViewRequest(viewOptions));
                
                Console.WriteLine("Document rendered to images successfully!");
                
                // Create a directory to store the images
                Directory.CreateDirectory("rendered_images");
                
                // Download each rendered image
                foreach (var page in response.Pages)
                {
                    Console.WriteLine($"Page {page.Number}: {page.DownloadUrl}");
                    
                    using (var webClient = new System.Net.WebClient())
                    {
                        webClient.Headers.Add("Authorization", "Bearer " + configuration.GetToken());
                        string outputPath = Path.Combine("rendered_images", $"page_{page.Number}.jpg");
                        webClient.DownloadFile(page.DownloadUrl, outputPath);
                        Console.WriteLine($"Downloaded {outputPath}");
                    }
                }
                
                // Open the directory with rendered images
                Process.Start(new ProcessStartInfo
                {
                    FileName = "rendered_images",
                    UseShellExecute = true
                });
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception while calling ViewApi: " + e.Message);
            }
            
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

What makes this example production-ready?

  • Proper error handling with try-catch blocks
  • Automatic directory creation for organized file storage
  • Progress feedback for long-running operations
  • Clean resource management with using statements

Python Implementation with Requests Integration

This Python example shows how to integrate the conversion process into a web application:

# Import modules
import os
import requests
import groupdocs_viewer_cloud

# Get your client ID and client secret from https://dashboard.groupdocs.cloud/
client_id = "YOUR_CLIENT_ID"
client_secret = "YOUR_CLIENT_SECRET"

# Create API instance
api_instance = groupdocs_viewer_cloud.ViewApi.from_keys(client_id, client_secret)

# Define rendering options
view_options = groupdocs_viewer_cloud.ViewOptions()
view_options.file_info = groupdocs_viewer_cloud.FileInfo()
view_options.file_info.file_path = "SampleFiles/sample.docx"
view_options.view_format = "JPG"
view_options.render_options = groupdocs_viewer_cloud.ImageOptions()
view_options.render_options.jpeg_quality = 90
view_options.render_options.width = 800
view_options.render_options.height = 1000

try:
    # Call the API to render the document
    request = groupdocs_viewer_cloud.CreateViewRequest(view_options)
    response = api_instance.create_view(request)
    
    print("Document rendered to images successfully!")
    
    # Create a directory to store the images
    os.makedirs("rendered_images", exist_ok=True)
    
    # Download each rendered image
    for page in response.pages:
        print(f"Page {page.number}: {page.download_url}")
        
        image_response = requests.get(
            page.download_url,
            headers={"Authorization": f"Bearer {api_instance.configuration.access_token}"}
        )
        
        if image_response.status_code == 200:
            output_path = os.path.join("rendered_images", f"page_{page.number}.jpg")
            with open(output_path, "wb") as file:
                file.write(image_response.content)
                print(f"Downloaded {output_path}")
    
    print(f"\nAll images have been downloaded to the 'rendered_images' directory.")
    
    # Open the first image in default image viewer
    first_image_path = os.path.abspath(os.path.join("rendered_images", "page_1.jpg"))
    print(f"Opening {first_image_path}")
    
    import webbrowser
    webbrowser.open(f'file://{first_image_path}')

except groupdocs_viewer_cloud.ApiException as e:
    print(f"Exception while calling ViewApi: {e}")

Python-specific advantages:

  • Easy integration with web frameworks like Flask or Django
  • Excellent for batch processing multiple documents
  • Simple file handling and directory management
  • Great for building automated document processing pipelines

One of the most common use cases is creating an interactive gallery to display your converted document pages. Here’s a complete HTML implementation:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document Image Gallery</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }
        h1 {
            text-align: center;
            color: #333;
        }
        .gallery {
            display: flex;
            flex-wrap: wrap;
            justify-content: center;
            gap: 20px;
            margin-top: 30px;
        }
        .thumbnail {
            border: 1px solid #ddd;
            border-radius: 5px;
            padding: 10px;
            cursor: pointer;
            transition: transform 0.3s;
            width: 200px;
        }
        .thumbnail:hover {
            transform: scale(1.05);
            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
        }
        .thumbnail img {
            width: 100%;
            height: auto;
            display: block;
        }
        .thumbnail p {
            margin: 10px 0 0;
            text-align: center;
        }
        .modal {
            display: none;
            position: fixed;
            z-index: 1000;
            left: 0;
            top: 0;
            width: 100%;
            height: 100%;
            background-color: rgba(0,0,0,0.9);
        }
        .modal-content {
            position: relative;
            margin: auto;
            display: block;
            max-width: 90%;
            max-height: 90%;
            top: 50%;
            transform: translateY(-50%);
        }
        .close {
            position: absolute;
            top: 15px;
            right: 35px;
            color: #f1f1f1;
            font-size: 40px;
            font-weight: bold;
            cursor: pointer;
        }
        .navigation {
            position: absolute;
            top: 50%;
            width: 100%;
            display: flex;
            justify-content: space-between;
        }
        .nav-btn {
            color: white;
            font-size: 30px;
            font-weight: bold;
            cursor: pointer;
            padding: 15px;
            user-select: none;
        }
    </style>
</head>
<body>
    <h1>Document Image Gallery</h1>
    
    <div class="gallery" id="gallery">
        <!-- Thumbnails will be added here dynamically -->
    </div>
    
    <div id="imageModal" class="modal">
        <span class="close" onclick="closeModal()">&times;</span>
        <img class="modal-content" id="modalImage">
        <div class="navigation">
            <span class="nav-btn" onclick="changeImage(-1)">&#10094;</span>
            <span class="nav-btn" onclick="changeImage(1)">&#10095;</span>
        </div>
    </div>
    
    <script>
        // Configuration - update with your rendered images
        const pages = [
            { number: 1, path: 'rendered_images/page_1.jpg' },
            { number: 2, path: 'rendered_images/page_2.jpg' },
            { number: 3, path: 'rendered_images/page_3.jpg' }
            // Add more pages as needed
        ];
        
        let currentImageIndex = 0;
        
        // Populate the gallery with thumbnails
        document.addEventListener('DOMContentLoaded', function() {
            const gallery = document.getElementById('gallery');
            
            pages.forEach((page, index) => {
                const thumbnail = document.createElement('div');
                thumbnail.className = 'thumbnail';
                thumbnail.innerHTML = `
                    <img src="${page.path}" alt="Page ${page.number}">
                    <p>Page ${page.number}</p>
                `;
                thumbnail.onclick = function() {
                    openModal(index);
                };
                gallery.appendChild(thumbnail);
            });
        });
        
        function openModal(index) {
            const modal = document.getElementById('imageModal');
            const modalImage = document.getElementById('modalImage');
            
            currentImageIndex = index;
            modalImage.src = pages[currentImageIndex].path;
            modal.style.display = 'block';
        }
        
        function closeModal() {
            document.getElementById('imageModal').style.display = 'none';
        }
        
        function changeImage(step) {
            currentImageIndex += step;
            
            // Wrap around to the beginning or end if needed
            if (currentImageIndex >= pages.length) {
                currentImageIndex = 0;
            } else if (currentImageIndex < 0) {
                currentImageIndex = pages.length - 1;
            }
            
            document.getElementById('modalImage').src = pages[currentImageIndex].path;
        }
        
        // Close modal when clicking outside the image
        window.onclick = function(event) {
            const modal = document.getElementById('imageModal');
            if (event.target === modal) {
                closeModal();
            }
        };
        
        // Handle keyboard navigation
        document.addEventListener('keydown', function(event) {
            if (document.getElementById('imageModal').style.display === 'block') {
                if (event.key === 'ArrowLeft') {
                    changeImage(-1);
                } else if (event.key === 'ArrowRight') {
                    changeImage(1);
                } else if (event.key === 'Escape') {
                    closeModal();
                }
            }
        });
    </script>
</body>
</html>

Gallery features:

  • Responsive design that works on all devices
  • Thumbnail previews for quick navigation
  • Full-screen modal view for detailed examination
  • Keyboard navigation (arrow keys and escape)
  • Touch-friendly interface for mobile devices

Advanced Features for Professional Applications

Text Extraction with Coordinates

One powerful feature is extracting text positions along with the image conversion. This enables searchable documents or text overlay features:

var viewOptions = new ViewOptions
{
    FileInfo = new FileInfo
    {
        FilePath = "SampleFiles/sample.docx"
    },
    ViewFormat = ViewOptions.ViewFormatEnum.PNG,
    RenderOptions = new ImageOptions
    {
        ExtractText = true
    }
};

Use cases for text extraction:

  • Building searchable document archives
  • Creating interactive documents with selectable text
  • Implementing document annotation features
  • Generating automatic document summaries

Adding Watermarks for Security

Protect your documents by adding watermarks during the conversion process:

var viewOptions = new ViewOptions
{
    FileInfo = new FileInfo
    {
        FilePath = "SampleFiles/sample.docx"
    },
    ViewFormat = ViewOptions.ViewFormatEnum.JPG,
    RenderOptions = new ImageOptions
    {
        Watermark = new Watermark
        {
            Text = "CONFIDENTIAL",
            Color = "#FF0000",
            Position = Watermark.PositionEnum.Diagonal,
            Size = Watermark.SizeEnum.Full
        }
    }
};

Watermark best practices:

  • Use semi-transparent colors (#80FF0000 instead of #FF0000)
  • Position watermarks diagonally for maximum visibility
  • Keep watermark text concise and readable
  • Consider different watermarks for different document types

Performance Optimization and Best Practices

Batch Processing Strategy

When converting multiple documents, implement batch processing to improve efficiency:

// Process multiple documents in parallel
var documents = new List<string> { "doc1.pdf", "doc2.docx", "doc3.pptx" };
var tasks = documents.Select(doc => ProcessDocumentAsync(doc));
await Task.WhenAll(tasks);

Caching Converted Images

Implement caching to avoid re-converting the same documents:

private bool IsImageCached(string filePath, int pageNumber)
{
    string cacheKey = $"{filePath}_page_{pageNumber}";
    return File.Exists(Path.Combine("cache", $"{cacheKey}.jpg"));
}

Memory Management Tips

  • Process large documents in chunks when possible
  • Dispose of API clients and responses properly
  • Monitor memory usage during batch operations
  • Consider using streaming for very large files

Common Issues and Troubleshooting

Problem: Images Appear Blurry or Low Quality

Solution: Increase the JPEG quality setting or switch to PNG format:

# Increase quality
"JpegQuality": 95

# Or switch to PNG for lossless compression
"ViewFormat": "PNG"

Problem: File Sizes Are Too Large

Solution: Optimize quality settings or reduce dimensions:

# Reduce quality for smaller files
"JpegQuality": 60

# Or reduce dimensions
"Width": 600,
"Height": 800

Problem: Conversion Takes Too Long

Solution: Optimize for performance:

  • Use JPG instead of PNG for faster processing
  • Reduce output dimensions
  • Process pages in parallel where possible
  • Consider caching frequently accessed documents

Problem: API Rate Limiting

Solution: Implement proper rate limiting and retry logic:

private async Task<T> ExecuteWithRetry<T>(Func<Task<T>> operation, int maxRetries = 3)
{
    for (int i = 0; i < maxRetries; i++)
    {
        try
        {
            return await operation();
        }
        catch (ApiException ex) when (ex.HttpStatusCode == 429)
        {
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, i))); // Exponential backoff
        }
    }
    throw new Exception("Max retries exceeded");
}

Cost Optimization and Usage Planning

Understanding Usage Costs

The GroupDocs.Viewer Cloud API charges based on:

  • Number of pages processed (not documents)
  • Storage usage for uploaded files
  • Bandwidth for downloading rendered images

Cost-Saving Strategies

  1. Optimize page ranges: Only convert pages you actually need
  2. Implement smart caching: Avoid re-converting the same documents
  3. Use appropriate quality settings: Don’t use maximum quality unless necessary
  4. Clean up storage: Remove old files to reduce storage costs

Usage Monitoring

// Track API usage in your application
private void LogApiUsage(string operation, int pageCount)
{
    var usageLog = new
    {
        Operation = operation,
        PageCount = pageCount,
        Timestamp = DateTime.UtcNow,
        CostEstimate = pageCount * 0.001 // Example cost per page
    };
    
    // Log to your monitoring system
    Logger.LogInformation("API Usage: {Usage}", JsonSerializer.Serialize(usageLog));
}

Hands-On Exercise: Optimize Quality vs. Size

Try this practical exercise to understand the quality-size trade-offs:

  1. Convert the same document with different quality settings:

    • Quality 95 (high quality)
    • Quality 75 (balanced)
    • Quality 50 (small files)

  2. Compare the results:

    • File sizes
    • Visual quality
    • Loading times in your application

  3. Find your optimal setting based on your specific use case and requirements.

Next Steps and Advanced Topics

Now that you’ve mastered the basics, consider exploring:

  • Advanced rendering options: Custom fonts, specific page ranges, and rotation
  • Integration patterns: Webhooks, background processing, and microservices
  • Security enhancements: Document encryption, access controls, and audit logging
  • Performance scaling: Load balancing, distributed processing, and CDN integration

Resources and Community Support

Essential Links:

Getting Help:

  • Technical Questions: Visit our support forum for community help
  • Sales Inquiries: Contact our sales team through the website
  • Bug Reports: Submit issues through the official support channels
  • Feature Requests: Share your ideas in the community forum

Frequently Asked Questions

How many documents can I convert with the free trial?

The free trial includes 150 conversion operations per month, with each page counting as one operation. This is perfect for testing and small projects.

What’s the maximum file size I can upload?

The API supports files up to 100MB. For larger files, consider splitting them or contacting support for enterprise options.

Can I convert password-protected PDFs?

Yes! Just include the password in your FileInfo object:

FileInfo = new FileInfo
{
    FilePath = "protected.pdf",
    Password = "your_password"
}

How long are converted images stored in the cloud?

Converted images are stored for 24 hours by default. You can configure longer retention periods in your account settings.

Can I use this for commercial applications?

Absolutely! The API is designed for commercial use. Check the pricing page for commercial license options.

What happens if my document contains unsupported fonts?

The API automatically substitutes similar fonts to maintain document layout. For best results, use common fonts or embed fonts in your documents.