COMPARAISON

PDFBolt vs IronPDF : Guide de comparaison technique

Mis à jour:

Lorsque les développeurs .NET ont besoin de créer des documents PDF, ils sont confrontés à une décision clé : utiliser des services basés sur le cloud comme PDFBoltou opter pour des bibliothèques auto-hébergées comme IronPDF. Cette analyse examine les deux options sur des aspects techniques importants afin d'aider les développeurs, les architectes et les décideurs à choisir l'outil le mieux adapté à leurs besoins en matière de génération de PDF.

Qu'est-ce que PDFBolt?

PDFBolt est un service d'API REST basé sur le cloud pour générer des PDF via des serveurs externes. Les développeurs envoient du contenu HTML ou des URL via des requêtes POST HTTP aux points de terminaison de l'API de PDFBolt, qui traitent le contenu à l'aide d'un navigateur Chromium sans tête et renvoient le PDF généré.

La configuration basée sur le cloud offre une intégration rapide : les développeurs obtiennent une clé API et effectuent des requêtes HTTP en utilisant le client HTTP standard de n'importe quel langage (par exemple, HttpClient en C#, requests en Python, fetch en Node.js). PDFBoltgère l'infrastructure de rendu, supprimant ainsi le besoin de ressources locales de génération de PDF.

Toutefois, cette commodité s'accompagne de compromis. Chaque document passe par les serveurs de PDFBoltsitués dans l'UE (Allemagne). Le niveau gratuit est limité à 100 documents par mois, avec des plans d'abonnement payants disponibles pour des volumes plus élevés. En outre, la connectivité réseau est obligatoire pour toutes les opérations de génération de PDF.

Qu'est-ce qu'IronPDF?

IronPDF est une bibliothèque .NET auto-hébergée qui effectue la génération de PDF localement sur vos serveurs. La classe ChromePdfRenderer utilise un moteur Chromium intégré pour convertir HTML, CSS et JavaScript en documents PDF de haute qualité sans aucun appel réseau externe.

La bibliothèque traite tous les documents au sein de l'infrastructure de votre application. Aucune donnée ne quitte vos serveurs et il n'y a aucune limite d'utilisation pour la génération de documents. Une fois la licence acquise, vous pouvez générer un nombre illimité de PDF sans frais par document.

IronPDF propose des méthodes synchrones et asynchrones, ainsi que des fonctionnalités étendues allant au-delà de la génération de base - notamment la fusion de PDF, le filigrane, l'extraction de texte et les paramètres de sécurité que les API du cloud ne peuvent généralement pas fournir.

Comparaison d'architecture

La principale différence entre PDFBoltetIronPDFréside dans l'endroit où s'effectue le traitement des documents. Cette distinction a une incidence sur tous les aspects, de la confidentialité des données à la fiabilité opérationnelle.

Fonction PDFBolt IronPDF
Hébergement Serveurs exclusivement en nuage (serveurs européens) Auto-hébergé
Lieu des données Serveurs externes (Allemagne) Vos serveurs uniquement
Confidentialité Documents traités en externe Confidentialité totale des données — traitement local, aucune transmission à un tiers
Limites d'utilisation Basé sur un quota (100-50 000/mois selon le plan) Nombre illimité
Internet requis Oui, toujours Non
Latence Inclut le temps de trajet aller-retour du réseau Traitement local
Opérations hors ligne Pas possible Entièrement pris en charge
Intégration C# API REST via HttpClient Intégration directe de la bibliothèque
Modèle de coût Abonnement mensuel avec quotas de documents Achat unique ou abonnement

Pour les applications traitant des documents sensibles — contrats, dossiers médicaux, données financières —, le fait que les données quittent ou non votre infrastructure est important.IronPDFtraite tout localement, de sorte qu'aucun contenu de document n'est transmis à l'extérieur. Cela simplifie la conformité avec le RGPD, la HIPAA et le SOC2, car il n'y a pas de processeur de données tiers impliqué et aucun transfert de données à auditer.

Conversion de base de HTML en PDF

Les deux outils gèrent la conversion HTML en PDF, mais avec des approches fondamentalement différentes — PDFBoltvia des appels à l'API REST etIronPDFvia une bibliothèque C#.

L'approche de PDFBoltHTML vers PDF:

// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = "<html><body><h1>Hello World</h1></body></html>";
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { html = base64Html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = "<html><body><h1>Hello World</h1></body></html>";
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { html = base64Html });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
Imports System
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")

        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim base64Html As String = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))

        Dim response = Await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            New With {.html = base64Html})
        Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Function
End Module
$vbLabelText   $csharpLabel

L'approcheIronPDFHTML-to-PDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Le point d'accès direct de l'API de PDFBoltrenvoie des données binaires PDF brutes dans le corps de la réponse HTTP, qui peuvent être enregistrées avec File.WriteAllBytes(). L'RenderHtmlAsPdf() deIronPDFrenvoie un objet PdfDocument avec des méthodes pratiques telles que SaveAs(), ainsi que des propriétés comme BinaryData et Stream pour une gestion alternative de la sortie.

Le processus de conversion de HTML en PDF dansIronPDFs'exécute entièrement localement, sans qu'aucun aller-retour sur le réseau n'ajoute de latence à chaque conversion.

Conversion d'URL en PDF

La conversion de pages web en PDF suit des schémas similaires, avec des différences notables dans la désignation et le traitement des méthodes.

L'approche de PDFBoltURL-to-PDF:

// REST API: requires an API key from pdfbolt.com
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { url = "https://www.example.com" });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
// REST API: requires an API key from pdfbolt.com
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new { url = "https://www.example.com" });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")

        Dim response = Await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            New With {.url = "https://www.example.com"})
        Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Function
End Module
$vbLabelText   $csharpLabel

Approche de l'URL vers le PDF d'IronPDF :

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF fournit une méthode RenderUrlAsPdf dédiée qui indique clairement l'opération effectuée. L'objet résultant PdfDocument offre la même interface riche pour l'enregistrement, l'accès aux données binaires ou la manipulation ultérieure.

Personnalisation de la taille des pages et des marges

Les documents professionnels exigent souvent des dimensions de page et des configurations de marge spécifiques. Les deux outils prennent en charge ces personnalisations avec différents modèles de configuration.

Configuration de la page PDFBolt:

// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = File.ReadAllText("input.html");
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new
            {
                html = base64Html,
                format = "A4",
                margin = new { top = "20mm", bottom = "20mm" }
            });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
// REST API: requires an API key from pdfbolt.com
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.IO;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");

        var html = File.ReadAllText("input.html");
        var base64Html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        var response = await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            new
            {
                html = base64Html,
                format = "A4",
                margin = new { top = "20mm", bottom = "20mm" }
            });
        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
Imports System
Imports System.Net.Http
Imports System.Net.Http.Json
Imports System.IO
Imports System.Text
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim client As New HttpClient()
        client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")

        Dim html As String = File.ReadAllText("input.html")
        Dim base64Html As String = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))

        Dim response As HttpResponseMessage = Await client.PostAsJsonAsync(
            "https://api.pdfbolt.com/v1/direct",
            New With {
                .html = base64Html,
                .format = "A4",
                .margin = New With {.top = "20mm", .bottom = "20mm"}
            })
        Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Function
End Module
$vbLabelText   $csharpLabel

Configuration des pages IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim html = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

PDFBolt accepte la configuration sous forme de paramètres JSON dans le corps de la requête API (format, margin).IronPDFcentralise toute la configuration par le biais de la propriété RenderingOptions, ce qui permet de découvrir les paramètres par le biais de l'autocomplétion de l'IDE.

PDFBolt prend en charge les marges dans plusieurs unités (px, po, cm, mm), tandis qu'IronPDF exprime les marges en millimètres. Les deux prennent en charge les tailles de papier standard — PDFBoltvia le paramètre de chaîne format (par exemple, "A4"), etIronPDFvia l'énumération PdfPaperSize.

Référence de mappage d'API

Pour les équipes envisageant une transition de PDFBoltà IronPDF, comprendre les mappages d'API aide à estimer l'effort. Notez que PDFBoltutilise des paramètres API REST (champs JSON), tandis qu'IronPDF utilise des classes et des méthodes C#.

Correspondances des opérations principales

PDFBolt (API REST) IronPDF (Bibliothèque C#)
POST /v1/direct avec {"html": "<base64>"} renderer.RenderHtmlAsPdf(html)
POST /v1/direct avec {"url": "... renderer.RenderUrlAsPdf(url)
Corps de réponse (octets PDF bruts) pdf.SaveAs(path)
"isEncoded": true (réponse en Base64) pdf.BinaryData

Correspondances de paramètres de configuration

PDFBolt (paramètre JSON) IronPDF (propriété C#)
"format": "A4" renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
"margin": {"top": "20mm"} renderer.RenderingOptions.MarginTop = 20
"margin": {"bottom": "20mm"} renderer.RenderingOptions.MarginBottom = 20
"margin": {"left": "15mm"} renderer.RenderingOptions.MarginLeft = 15
"margin": {"right": "15mm"} renderer.RenderingOptions.MarginRight = 15

Correspondances de contenu dynamique pour l'en-tête/pied de page

Les deux outils prennent en charge les en-têtes et pieds de page basés sur HTML avec du contenu dynamique, utilisant une syntaxe différente :

PDFBolt (classe CSS en HTML) IronPDF (espace réservé) Objectif
<span class="pageNumber"></span> {page} Numéro de page actuel
<span class="totalPages"></span> {total-pages} Nombre total de pages
<span class="date"></span> {date} Date actuelle
<span class="title"></span> {html-title} Titre du document
<span class="url"></span> {url} URL de la page

PDFBolt etIronPDFprennent en charge les en-têtes et pieds de page basés sur HTML avec du style CSS. Les paramètres headerTemplate et footerTemplate de PDFBoltacceptent du HTML encodé en Base64, tandis qu'IronPDF utilise directement des chaînes HTML dans ses options de rendu.

Comparaison de la disponibilité des fonctionnalités

Au-delà de la conversion HTML en PDF de base, les outils diffèrent considérablement dans les capacités disponibles.

Fonction PDFBolt IronPDF
HTML vers PDF ✓ ✓
URL vers PDF ✓ ✓
En-têtes/Pieds de page ✓ (HTML) ✓ (HTML)
Numéros de page ✓ ✓
Taille de page personnalisée ✓ ✓
Marges ✓ ✓
Fusion de PDF ✗ ✓
Fractionnement de PDF ✗ ✓
Filigranes ✗ ✓
Protection par mot de passe ✗ ✓
Extraction de texte ✗ ✓
PDF vers images ✗ ✓
Remplissage de formulaires ✗ ✓
Signatures numériques ✗ ✓
Fonctionnement hors ligne ✗ ✓
Traitement illimité Basé sur un quota (jusqu'à 50 000/mois) Nombre illimité

IronPDF offre des fonctionnalités étendues de manipulation de PDF, notamment la fusion, la division, le filigrane, et des paramètres de sécurité que les API du cloud ne peuvent généralement pas offrir en raison de la nature apatride des demandes d'API.

Confidentialité des données et conformité

La différence architecturale crée des caractéristiques de traitement des données fondamentalement différentes :

Flux de données PDFBolt:

  1. Votre application envoie HTML/URL aux serveurs de PDFBoltsitués dans l'UE (Allemagne)
  2. PDFBolttraite le document à l'aide de son infrastructure cloud
  3. Retours PDF générés sur le réseau
  4. Le contenu du document est transmis et traité sur des serveurs externes

Flux de données IronPDF:

  1. Votre application traite HTML/URL localement
  2. Le moteur Chromium rend le PDF en cours de traitement
  3. Les données PDF ne quittent jamais vos serveurs
  4. Aucun processeur de données tiers impliqué — aucune négociation de DPA requise

Avec IronPDF, les documents contenant des informations personnellement identifiables, des informations de santé protégées ou des données commerciales confidentielles ne quittent jamais votre infrastructure. La bibliothèque comprend également des fonctionnalités de sécurité intégrées qui soutiennent les flux de travail de conformité : protection par mot de passe et cryptage (jusqu'à 256 bits AES), signatures numériques avec certificats PFX/P12 et support HSM, rédaction de texte pour la suppression permanente de PII, et la conformité PDF/A pour les exigences d'archivage à long terme. Pour les environnements isolés,IronPDFfonctionne sans connexion Internet.

Quand les équipes envisagent de passer de PDFBoltà IronPDF

Plusieurs facteurs poussent les équipes à évaluerIronPDFcomme alternative à PDFBolt:

Exigences en matière de confidentialité des données : Les organisations soumises au RGPD, à la HIPAA, ou à des politiques internes de gouvernance des données peuvent exiger que les documents ne quittent jamais leur infrastructure. Le modèle de traitement local d'IronPDF satisfait à cela par conception — aucune donnée n'est transmise à l'extérieur, et les fonctionnalités de cryptage et de rédaction intégrées soutiennent directement les flux de travail de conformité.

Croissance du volume d'utilisation : Le niveau gratuit de PDFBoltest limité à 100 documents par mois (les demandes au-delà de cela sont bloquées, non facturées). Les plans payants vont de 19 $/mois (2 000 documents) à 249 $/mois (50 000 documents), avec des dépassements en option sur les niveaux payants.IronPDFn'a pas de quotas ou de mesure de documents — une fois sous licence, la génération est illimitée.

Fiabilité du réseau: Les API en nuage nécessitent une connectivité réseau pour chaque opération. Les applications déployées dans des environnements à connectivité intermittente, ou celles nécessitant une haute disponibilité, bénéficient d'un traitement local qui continue à fonctionner quel que soit l'état du réseau.

Sensibilité à la latence : Chaque conversion PDFBoltcomprend le temps de trajet aller-retour du réseau en plus du temps de rendu.IronPDFtraite les documents localement, évitant ainsi la surcharge du réseau.

Exigences en matière de fonctionnalités: Lorsque des applications ont besoin de fusionner des PDF, de filigrane, d'extraction de texte ou de paramètres de sécurité, les API en nuage ne peuvent souvent pas fournir ces fonctionnalités. L'ensemble des fonctionnalités d'IronPDF permet de répondre à ces besoins sans services supplémentaires.

Gestion des clés API : Les clés API cloud nécessitent des pratiques de stockage et de rotation sécurisées, car elles donnent accès à un service facturable. Le modèle de clé de licence d'IronPDF s'authentifie localement sans implications de facturation par utilisation.

Comparaison d'installation

Configuration PDFBolt: PDFBolt ne nécessite aucune installation de package — c'est une API REST. Les développeurs s'inscrivent sur pdfbolt.com, obtiennent une clé API et font des requêtes HTTP en utilisant le client HTTP standard de leur langage :

var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
Dim client As New HttpClient()
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")
$vbLabelText   $csharpLabel

Installation d'IronPDF:

Install-Package IronPdf
Install-Package IronPdf
SHELL

IronPDF nécessite la configuration d'une clé de licence au démarrage de l'application :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

PDFBolt est une API REST agnostique au langage accessible depuis n'importe quelle plateforme (C#, Node.js, Python, Java, Go, PHP, Rust, et plus).IronPDFest une bibliothèque .NET prenant en charge le .NET Framework et les versions modernes de .NET, compatible avec les applications ciblant .NET 10 et C# 14.

Considérations sur les modèles asynchrones et synchrones

L'architecture basée sur le cloud de PDFBoltutilise des modèles HTTP asynchrones pour les opérations réseau. PDFBoltpropose trois types de points de terminaison : direct (réponse binaire synchrone), sync (JSON synchrone avec URL de téléchargement), et async (basé sur webhook) :

// PDFBoltREST API pattern - async HTTP call
var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
var response = await client.PostAsJsonAsync(
    "https://api.pdfbolt.com/v1/direct",
    new { html = base64Html });
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
// PDFBoltREST API pattern - async HTTP call
var client = new HttpClient();
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY");
var response = await client.PostAsJsonAsync(
    "https://api.pdfbolt.com/v1/direct",
    new { html = base64Html });
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Threading.Tasks

' PDFBoltREST API pattern - async HTTP call
Dim client As New HttpClient()
client.DefaultRequestHeaders.Add("API-KEY", "YOUR-API-KEY")
Dim response As HttpResponseMessage = Await client.PostAsJsonAsync(
    "https://api.pdfbolt.com/v1/direct",
    New With {.html = base64Html})
Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
$vbLabelText   $csharpLabel

IronPDF fournit des méthodes synchrones par défaut puisque le traitement local ne nécessite pas d'asynchrone :

//IronPDFlocal pattern - sync by default
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
//IronPDFlocal pattern - sync by default
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
'IronPDFlocal pattern - sync by default
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

Pour les applications qui bénéficient des modèles asynchrones,IronPDFpropose également des variantes de méthodes asynchrones :

//IronPDFasync option
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
//IronPDFasync option
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
$vbLabelText   $csharpLabel

Caractéristiques de performance

Le traitement local par rapport au traitement cloud crée différents profils de performance :

Métrique PDFBolt IronPDF
Traitement Rendu cloud + transfert réseau Rendu local
Dépendance au réseau Chaque requête nécessite une connectivité Aucune
Traitement par lots Taux limité (20-150 requêtes/min selon le plan) Aucune limite de débit
Requêtes concurrentes 1-20 selon le plan Limité par les ressources du serveur
Fonctionnement hors ligne Pas possible Entièrement pris en charge

Le moteur Chromium intégré d'IronPDF a un surcoût d'initialisation à la première utilisation, mais les rendus suivants évitent la surcharge réseau inhérente aux appels API cloud. Les performances de PDFBoltdépendent des conditions réseau, de la complexité du document, et de la charge actuelle du serveur.

Prise de décision

Le choix entre PDFBoltetIronPDFdépend de vos besoins spécifiques :

Considérez PDFBoltsi : Vous avez besoin d'une intégration rapide pour un prototype, vos volumes de documents correspondent aux niveaux d'abonnement de PDFBolt, vous êtes à l'aise avec le traitement de documents basé sur le cloud, et la connectivité réseau est fiable.

ConsidérezIronPDFsi : Vous avez besoin d'un traitement local des données pour des raisons de confidentialité ou de conformité, vous générez plus de 100 documents par mois, vous avez besoin de manipuler des PDF au-delà de la génération (fusion, filigrane, sécurité), vous avez besoin d'une capacité de fonctionnement hors ligne, ou la latence importe pour l'expérience de l'utilisateur.

Pour les équipes qui créent des applications de production en 2025 et qui planifient pour 2026, l'architecture auto-hébergée d'IronPDF offre une indépendance opérationnelle et des capacités complètes que les API du cloud ne peuvent pas égaler.

Commencer avec IronPDF

Pour évaluerIronPDFpour vos besoins en matière de génération de PDF :

  1. Installez le package NuGet IronPDF : Install-Package IronPdf
  2. Consultez le tutoriel du HTML au PDF pour connaître les modèles de conversion de base
  3. Explorez la conversion d'URL en PDF pour la capture de pages web
  4. Consultez la section tutoriels pour des exemples complets

La documentation IronPDF fournit des conseils détaillés pour les scénarios courants, et la référence API documente toutes les classes et méthodes disponibles.