Migrar doPDFBoltpara IronPDF move seu fluxo de trabalho PDF .NET de um serviço em nuvem SaaS REST apenas para uma biblioteca autônoma com processamento de documentos local e sem cotas por documento. Este guia fornece um caminho de migração passo a passo que elimina dependências de rede, limites de uso mensais e transmissão de dados externos enquanto adiciona recursos de manipulação de PDF que oPDFBoltnão fornece.
PDFBolt é uma plataforma SaaS apenas em nuvem exposta como uma API REST; não há SDK oficial do .NET e nenhum pacote PDFBolt NuGet. A integração é feita manualmente com HttpClient contra https://api.pdfbolt.com/v1/direct. Embora conveniente para protótipos rápidos, essa arquitetura cria desafios para aplicações de produção:
Processamento Apenas na Nuvem: Todo documento passa pelos servidores doPDFBolt— não há opção de hospedagem própria, o que pode ser um obstáculo para equipes que precisam de mais controle sobre o fluxo de dados.
Considerações de Privacidade de Dados: Documentos sensíveis (contratos, registros médicos, dados financeiros) são transmitidos externamente. Empresas lidando com dados regulamentados terão preocupações legítimas de revisão.
Limites de Uso: O nível gratuito é limitado a 100 documentos por mês, 20 requisições/minuto, 1 requisição concorrente, o que pode não ser suficiente para cargas de trabalho de produção. Níveis pagos (conforme pdfbolt.com/pricing) escalam de $19/mês a $249/mês.
Dependência de Rede: Interrupções na internet ou inatividade doPDFBoltsignificam que sua geração de PDF pára completamente.
Latência: O tempo de ida e volta na rede adiciona segundos a cada conversão em comparação com o processamento local.
Revisão de Conformidade: Auditorias de GDPR, HIPAA, e SOC2 normalmente exigem documentação adicional quando o processamento de documentos externos está envolvido.
Segurança da chave de API: O vazamento de chaves de API pode resultar em uso não autorizado cobrado em sua conta.
Dependência do Fornecedor: Sua aplicação deixa de funcionar se oPDFBoltmudar os termos ou fechar.
| Preocupação | PDFBolt | IronPDF |
|---|---|---|
| Localização dos dados | Servidores externos | Somente seus servidores |
| Limites de uso | 100 gratuitos/mês, depois assinaturas escalonadas | Ilimitado |
| É necessário ter acesso à internet. | Sim, sempre | Não |
| Latência | viagem de ida e volta na rede | Local |
| Conformidade | Complexo (processamento externo) | Simples (processamento local) |
| Modelo de custo | Níveis de assinatura mensal ($19–$249/mês) | Pagamento único ou anual |
| Operação offline | Impossível | Suporte completo |
| Riscos da chave de API | Vazado = faturado | Chave de licença, sem risco de cobrança |
IronPDF fornece uma base hospedada localmente no .NET moderno que mantém o processamento de documentos local e remove a dependência de um serviço de nuvem externo.
OPDFBoltnão possui um SDK oficial do .NET e nenhum pacote PDFBolt NuGet, então não há nada para desinstalar. A limpeza do lado doPDFBolté excluir o wrapper HttpClient feito à mão e DTOs de solicitação/resposta. Então instale o 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 allPDFBoltREST 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 + cabeçalho API-KEY | new ChromePdfRenderer() |
| Corpo de requisição JSON | renderer.RenderingOptions |
POST https://api.pdfbolt.com/v1/direct | renderer.RenderHtmlAsPdf(...) / RenderUrlAsPdf(...) |
Resposta byte[] | PdfDocument |
| PDFBolt (REST) | IronPDF |
|---|---|
POST /v1/direct com { "html": <base64> } | renderer.RenderHtmlAsPdf(html) |
POST /v1/direct com { "url": "..." } | renderer.RenderUrlAsPdf(url) |
| PDFBolt (REST) | IronPDF |
|---|---|
await response.Content.ReadAsByteArrayAsync() então File.WriteAllBytes | pdf.SaveAs(path) |
await response.Content.ReadAsByteArrayAsync() | pdf.BinaryData |
| JSON do 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(dentro de headerTemplate codificado em base64 / footerTemplate) | IronPDF(HtmlFragment token) |
|---|---|
<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 ModuleApó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 ClassA diferença estrutural é o modelo de integração. OPDFBoltexige que você codifique em base64 o HTML, construa uma carga JSON, defina o cabeçalho API-KEY, POST para https://api.pdfbolt.com/v1/direct, aguarde a resposta e escreva os bytes retornados no disco você mesmo.
O ChromePdfRenderer.RenderHtmlAsPdf() do IronPDF retorna um objeto PdfDocument com um método SaveAs() embutido. O modelo orientado a objetos permite que você manipule o PDF (adicione marcas d'água, mescle documentos, aplique segurança) antes de salvar. Se você precisar dos bytes brutos para compatibilidade com o código existente, use pdf.BinaryData. Consulte a documentação de conversão de HTML para PDF para obter opções de renderização adicionais.
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 ModuleApó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 ClassDo lado do PDFBolt, a conversão de URL ainda requer a viagem completa REST: construa o corpo JSON, defina o cabeçalho da chave da API, aguarde o POST, e escreva os bytes de resposta. Mesmo que você já esteja apontando para uma URL pública, a obtenção e a renderização ocorrem nos servidores do PDFBolt.
O RenderUrlAsPdf() do IronPDF retorna um PdfDocument com o método SaveAs() embutido. A principal vantagem é que o IronPDF executa a obtenção da URL e a renderização do PDF localmente — nenhum dado do documento sai da sua infraestrutura. Saiba mais sobre a conversão de URL para 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 ModuleApó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 ClassEste exemplo mostra o mapeamento de configuração da página. OPDFBoltaceita format de nível superior mais um objeto aninhado margin cujos valores são strings estilo CSS ("20mm"). O IronPDF usa um objeto RenderingOptions no renderizador com propriedades fortemente tipadas.
Os principais mapeamentos:
"format": "A4" → PdfPaperSize.A4 (enum fortemente tipado)"margin": { "top": "20mm" } → RenderingOptions.MarginTop = 20 (mm numérico)As margens do IronPDF são sempre milímetros numéricos, então as strings de unidade CSS doPDFBoltcomo "20mm" mapeiam diretamente. O namespace IronPdf.Rendering é necessário para acesso ao enum PdfPaperSize. Para configurações de página adicionais, consulte a documentação de opções de renderização.
O endpoint /v1/direct doPDFBoltretorna o PDF bruto como corpo da resposta HTTP; O IronPDF retorna um 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;O formato de integração muda de cliente REST para biblioteca em processo:
// 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()A configuração doPDFBolté campos JSON no corpo da requisição; O IronPDF usa 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 = 20OPDFBoltrequer um cabeçalho API-KEY em cada solicitação; o IronPDF usa uma chave de licença única:
// 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()O processamento local significa que não há erros de rede para lidar:
// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)
// IronPDF: Remove network-specific catches entirelynetApós migrar para o IronPDF, você ganha capacidades que oPDFBoltnão oferece:
// 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 no NuGetProblema: Procurando por using PDFBolt; / new HtmlToPdfConverter() no IronPDF.
Solução: OPDFBoltnão possui um SDK .NET — sua integração é HttpClient contra https://api.pdfbolt.com/v1/direct. O IronPDF substitui totalmente esse wrapper com ChromePdfRenderer:
// IronPDF
var renderer = new ChromePdfRenderer();' IronPDF
Dim renderer As New ChromePdfRenderer()ConvertHtmlString?Problema: Migrando um wrapperPDFBoltinterno que expôs um método ConvertHtmlString(html).
Solution: Use RenderHtmlAsPdf():
// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);netConvertUrl?Problema: Migrando um wrapperPDFBoltinterno que expôs um método ConvertUrl(url).
Solution: Use RenderUrlAsPdf():
// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);netformat → EnumProblema: Traduzindo o campo JSON "format": "A4" do PDFBolt.
Solução: Use PdfPaperSize de IronPdf.Rendering:
// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;Imports IronPdf.Rendering
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4Problema: A renderização inicial demora mais do que o esperado.
Solução: O mecanismo Chromium inicializa no primeiro uso. Pré-aqueça, se necessário:
// 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 feito à mão e DTOs (sem pacote NuGet para desinstalar)IronPdf: dotnet add package IronPdfusing IronPdf;using IronPdf.Rendering; para enums de tamanho de papelHttpClient + API-KEY por ChromePdfRendererPOST /v1/direct por RenderHtmlAsPdf() / RenderUrlAsPdf()await response.Content.ReadAsByteArrayAsync() + File.WriteAllBytes() por pdf.SaveAs() (ou pdf.BinaryData se os bytes ainda forem necessários)"format" / "margin" para RenderingOptions.PaperSize / RenderingOptions.MarginTop, etc.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
