Migrer de PDFBoltà IronPDF transfère votre flux de travail PDF .NET d'un service cloud SaaS REST à une bibliothèque auto-hébergée avec traitement de documents local et sans quotas par document. Ce guide fournit un chemin de migration étape par étape qui élimine les dépendances réseau, les plafonds d'utilisation mensuels et la transmission de données externes tout en ajoutant des fonctionnalités de manipulation de PDF que PDFBoltne fournit pas.
PDFBolt est une plateforme SaaS uniquement cloud exposée en tant qu'API REST ; il n'y a pas de SDK .NET officiel et pas de paquet NuGet PDFBolt. L'intégration est faite manuellement avec HttpClient contre https://api.pdfbolt.com/v1/direct. Bien qu'elle soit pratique pour des prototypes rapides, cette architecture crée des défis pour les applications de production :
Traitement uniquement cloud : Chaque document passe par les serveurs de PDFBolt— il n'y a pas d'option auto-hébergée, ce qui peut être un obstacle pour les équipes qui ont besoin de plus de contrôle sur le flux de données.
Considérations sur la confidentialité des données : Les documents sensibles (contrats, dossiers médicaux, données financières) sont transmis en externe. Les entreprises traitant des données réglementées auront des préoccupations légitimes.
Limites d'utilisation : Le plan gratuit est limité à 100 documents par mois, 20 requêtes par minute, 1 requête simultanée, ce qui peut ne pas suffire pour les charges de travail de production. Les niveaux payants (par pdfbolt.com/pricing) vont de 19 $/mois à 249 $/mois.
Dépendance réseau : Les pannes Internet ou les temps d'arrêt de PDFBoltsignifient que votre génération de PDF s'arrête entièrement.
Latence : L'aller-retour sur le réseau ajoute des secondes à chaque conversion par rapport au traitement local.
Examen de conformité : Les audits GDPR, HIPAA et SOC2 nécessitent généralement une documentation supplémentaire lorsque le traitement de documents externes est impliqué.
Sécurité des clés API : Les fuites de clés API peuvent entraîner une utilisation non autorisée facturée sur votre compte.
Enfermement par le vendeur : Votre application s'arrête si PDFBoltchange les termes ou ferme.
| Concerne| PDFBolt|IronPDF| |---------|---------|---------| | Lieu des données| Serveurs externes| Vos serveurs uniquement| | Limites d'utilisation|100 gratuits/mois, puis abonnements par niveaux| Nombre illimité| | Internet requis| Oui, toujours| Non | | Latence| Aller-retour sur le réseau| Localement| | Conformité| Complexe (sous-traitance)| Simple (traitement local)| | Modèle de coût|Forfaits d'abonnement mensuels (19 $ – 249 $/mo)| Une seule fois ou une fois par an| | Opérations hors ligne| Impossible| Entièrement pris en charge| | Risques clés de l'API| Leaked = facturé| Clé de licence, pas de risque de facturation|
IronPDF fournit une base auto-hébergée sur la plateforme .NET moderne qui garde le traitement des documents local et élimine la dépendance à un service cloud externe.
PDFBolt n'a pas de SDK .NET officiel et pas de paquet NuGet PDFBolt, donc il n'y a rien à désinstaller. Le nettoyage du côté de PDFBoltconsiste à supprimer le wrapper HttpClient fait à la main et les DTO de requête/réponse. Ensuite, installez IronPDF:
# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"# Find all PDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .
# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .| PDFBolt(REST) |IronPDF|
|----------------|---------|
| HttpClient + API-KEY en-tête | new ChromePdfRenderer() |
| Corps de requête JSON | renderer.RenderingOptions |
| POST https://api.pdfbolt.com/v1/direct | renderer.RenderHtmlAsPdf(...) / RenderUrlAsPdf(...) |
| Réponse byte[] | PdfDocument |
| PDFBolt(REST) |IronPDF|
|----------------|---------|
| POST /v1/direct avec { "html": <base64> } | renderer.RenderHtmlAsPdf(html) |
| POST /v1/direct avec { "url": "..." } | renderer.RenderUrlAsPdf(url) |
| PDFBolt(REST) |IronPDF|
|----------------|---------|
| await response.Content.ReadAsByteArrayAsync() puis File.WriteAllBytes | pdf.SaveAs(path) |
| await response.Content.ReadAsByteArrayAsync() | pdf.BinaryData |
| JSON PDFBolt|IronPDF|
|--------------|---------|
| "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 |
| PDFBolt(encodé en base64 headerTemplate / footerTemplate) |IronPDF(HtmlFragment jeton) |
|---|---|
| <span class="pageNumber"></span> | {page} |
| <span class="totalPages"></span> | {total-pages} |
| <span class="date"></span> | {date} |
| <span class="title"></span> | {html-title} |
Before (PDFBolt — REST via HttpClient):
// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
var html = "<html><body><h1>Hello World</h1></body></html>";
var payload = JsonSerializer.Serialize(new
{
html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
});
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
using var content = new StringContent(payload, Encoding.UTF8, "application/json");
using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
response.EnsureSuccessStatusCode();
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);
}
}Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
Dim payload As String = JsonSerializer.Serialize(New With {
.html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
})
Using http As New HttpClient()
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
Using content As New StringContent(payload, Encoding.UTF8, "application/json")
Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
response.EnsureSuccessStatusCode()
Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
End Using
End Using
End Using
End Function
End ModuleAprès (IronPDF):
// 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 ClassLa différence structurelle est le modèle d'intégration. PDFBoltvous oblige à encoder en base64 le HTML, à construire une charge utile JSON, à définir l'en-tête API-KEY, POST vers https://api.pdfbolt.com/v1/direct, à attendre la réponse et à écrire vous-même les octets retournés sur le disque.
L'ChromePdfRenderer.RenderHtmlAsPdf() d'IronPDF renvoie un objet PdfDocument avec une méthode SaveAs() intégrée. Le modèle orienté objet vous permet de manipuler le PDF (ajouter des filigranes, fusionner des documents, appliquer la sécurité) avant de l'enregistrer. Si vous avez besoin des octets bruts pour la compatibilité avec le code existant, utilisez pdf.BinaryData. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.
Before (PDFBolt — REST via HttpClient):
// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
using var content = new StringContent(payload, Encoding.UTF8, "application/json");
using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
response.EnsureSuccessStatusCode();
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
}
}Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Dim payload = JsonSerializer.Serialize(New With {.url = "https://www.example.com"})
Using http As New HttpClient()
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
Using content As New StringContent(payload, Encoding.UTF8, "application/json")
Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
response.EnsureSuccessStatusCode()
Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
End Using
End Using
End Using
End Function
End ModuleAprès (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");
}
}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 ClassDu côté de PDFBolt, la conversion d'URL nécessite toujours un aller-retour complet REST : créer le corps JSON, définir l'entête de clé API, attendre le POST, et écrire les octets de réponse. Bien que vous pointiez déjà vers une URL publique, l'extraction et le rendu se produisent tous deux sur les serveurs de PDFBolt.
L'RenderUrlAsPdf() d'IronPDF renvoie un PdfDocument avec la méthode SaveAs() intégrée. L'avantage clé est qu'IronPDF effectue l'extraction URL et le rendu PDF localement — aucune donnée de document ne quitte votre infrastructure. En savoir plus sur la conversion d'URL en PDF.
Before (PDFBolt — REST via HttpClient):
// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
var html = await File.ReadAllTextAsync("input.html");
var payload = JsonSerializer.Serialize(new
{
html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
format = "A4",
margin = new { top = "20mm", bottom = "20mm" },
printBackground = true
});
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
using var content = new StringContent(payload, Encoding.UTF8, "application/json");
using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
response.EnsureSuccessStatusCode();
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);
}
}Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks
Module Program
Async Function Main() As Task
Dim html = Await File.ReadAllTextAsync("input.html")
Dim payload = JsonSerializer.Serialize(New With {
.html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
.format = "A4",
.margin = New With {.top = "20mm", .bottom = "20mm"},
.printBackground = True
})
Using http As New HttpClient()
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
Using content As New StringContent(payload, Encoding.UTF8, "application/json")
Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
response.EnsureSuccessStatusCode()
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
End Using
End Using
End Using
End Function
End ModuleAprès (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");
}
}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 ClassCet exemple montre la correspondance de configuration de page. PDFBoltaccepte des format de haut niveau plus un objet imbriqué margin dont les valeurs sont des chaînes style CSS ("20mm").IronPDF utilise un objet RenderingOptions sur le rendu avec des propriétés fortement typées.
Les principales correspondances :
"format": "A4" → PdfPaperSize.A4 (énumération fortement typée)"margin": { "top": "20mm" } → RenderingOptions.MarginTop = 20 (mm numériques)Les marges d'IronPDF sont toujours en millimètres numériques, donc les chaînes d'unités CSS de PDFBoltcomme "20mm" se mappent directement. L'espace de noms IronPdf.Rendering est requis pour accéder à l'énumération PdfPaperSize. Pour des configurations de page supplémentaires, voir la documentation des options de rendu.
Le point de terminaison /v1/direct de PDFBoltrenvoie le PDF brut comme le corps de réponse HTTP ;IronPDF renvoie un PdfDocument :
// PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);
//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;La forme d'intégration change du client REST vers une bibliothèque en processus :
// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct
// IronPDF
var renderer = new ChromePdfRenderer();Imports System.Net.Http
' PDFBolt
Using http As New HttpClient()
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
' ... build JSON, POST to https://api.pdfbolt.com/v1/direct
End Using
' IronPDF
Dim renderer As New ChromePdfRenderer()La configuration de PDFBoltest des champs JSON sur le corps de la requête ;IronPDF utilise RenderingOptions :
// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }
// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;' PDFBolt: JSON request fields
New With {Key .format = "A4", Key .margin = New With {Key .top = "20mm"}}
' IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20PDFBolt nécessite un en-tête API-KEY sur chaque requête ;IronPDF utilise une clé de licence unique :
// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);
// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();' PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config("PDFBolt:ApiKey"))
' IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()Le traitement local signifie qu'il n'y a pas d'erreurs de réseau à gérer :
// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)
// IronPDF: Remove network-specific catches entirelynetAprès la migration vers IronPDF, vous gagnez des capacités que PDFBoltne fournit pas :
// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);
// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");
// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";
// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();
// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");' PDF Merging (not available in PDFBolt)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
' Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>")
' Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret"
' Text Extraction (not available in PDFBolt)
Dim text As String = pdf.ExtractAllText()
' PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png")PDFBolt sur NuGetProblème : Recherche de using PDFBolt; / new HtmlToPdfConverter() dans IronPDF.
Solution : PDFBoltn'a pas de SDK .NET — son intégration est HttpClient contre https://api.pdfbolt.com/v1/direct.IronPDF remplace entièrement ce wrapper par ChromePdfRenderer :
// IronPDF
var renderer = new ChromePdfRenderer();' IronPDF
Dim renderer As New ChromePdfRenderer()ConvertHtmlString ?Problème : Migration d'un wrapper PDFBoltinterne qui exposait une méthode ConvertHtmlString(html).
Solution: Use RenderHtmlAsPdf():
// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);netConvertUrl ?Problème : Migration d'un wrapper PDFBoltinterne qui exposait une méthode ConvertUrl(url).
Solution: Use RenderUrlAsPdf():
// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);netformat → EnumProblème : Traduction du champ JSON "format": "A4" de PDFBolt.
Solution : Utilisez PdfPaperSize de IronPdf.Rendering :
// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;Imports IronPdf.Rendering
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4Problème : Le rendu initial prend plus de temps que prévu.
Solution : Le moteur Chromium s'initialise lors de sa première utilisation. Préchauffez si nécessaire :
// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");' Warm up during application startup
Dim renderer As New ChromePdfRenderer()
renderer.RenderHtmlAsPdf("<html><body></body></html>")api.pdfbolt.com)format, margin, printBackground, headerTemplate, etc.)HttpClient faits à la main (aucun paquet NuGet à désinstaller)IronPdf : dotnet add package IronPdfusing IronPdf;using IronPdf.Rendering; pour les énumérations de taille de papierHttpClient + API-KEY par ChromePdfRendererPOST /v1/direct par RenderHtmlAsPdf() / RenderUrlAsPdf()await response.Content.ReadAsByteArrayAsync() + File.WriteAllBytes() par pdf.SaveAs() (ou pdf.BinaryData si des octets sont encore nécessaires)"format" / "margin" vers RenderingOptions.PaperSize / RenderingOptions.MarginTop etc.
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
