OPDFmyURLé um serviço de API baseado na nuvem, projetado para converter URLs e conteúdo HTML em documentos PDF. O serviço processa todas as conversões em servidores externos, proporcionando um caminho de integração simples que requer infraestrutura local mínima. No entanto, essa arquitetura dependente da nuvem gera preocupações significativas para aplicações de produção que lidam com dados sensíveis, exigem capacidade offline ou precisam evitar custos contínuos de assinatura.

Este guia fornece um caminho completo de migração doPDFmyURLpara o IronPDF, com instruções passo a passo, comparações de código e exemplos práticos para desenvolvedores .NET profissionais que estejam avaliando essa transição.

Por que migrar do PDFmyURL?

O modelo de processamento em nuvem doPDFmyURLapresenta diversos desafios que as equipes de desenvolvimento devem considerar:

Privacidade e segurança de dados: Todos os documentos que você converte são enviados e processados ​​pelos servidores daPDFmyURL— contratos confidenciais, relatórios financeiros e dados pessoais são todos processados ​​externamente.

Custos de Assinatura Continuada: Planos começam em $20/mês (Starter, 500 PDFs), $40/mês (Professional, 2.000 PDFs), e $70/mês (Advanced, 5.000 PDFs), sem propriedade em qualquer nível. Este modelo de assinatura significa despesa contínua independentemente dos padrões de uso.

Dependência da Internet: Toda conversão requer conectividade de rede. Os aplicativos não conseguem processar PDFs offline ou durante interrupções de rede.

Limites de taxa e restrição: as chamadas de API podem ser limitadas durante períodos de pico de uso, o que pode afetar o desempenho do aplicativo.

Disponibilidade do serviço: Sua aplicação depende de um serviço de terceiros estar online e funcionando.

Dependência de fornecedor: alterações na API podem interromper sua integração sem aviso prévio, exigindo atualizações reativas de código.

##IronPDF vs PDFmyURL: Comparação de Recursos

Compreender as diferenças arquitetônicas ajuda os responsáveis ​​pelas decisões técnicas a avaliar o investimento em migração:

Guia rápido: Migração doPDFmyURLpara o IronPDF

A migração pode começar imediatamente com esses passos fundamentais.

Passo 1: Instale o IronPDF

PDFmyURL não possui pacote NuGet — o serviço é uma API REST, e o componente opcional PDFmyURL.NET.dll é fornecido como download direto de DLL (não em nuget.org). A maioria das integrações chama a API com WebClient / HttpClient, então a migração é principalmente sobre o código, não sobre referências de pacote. Se você usou o assembly PDFmyURL.NET.dll, remova a referência do seu projeto após a migração.

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

Etapa 2: Atualizar Namespaces

Substituir importaçõesPDFmyURLpor IronPDF:

// Before:PDFmyURL— either plain HttpClient/WebClient against pdfmyurl.com/api,
// or the optional .NET component:
using PDFmyURLdotNET;          // only if you used PDFmyURL.NET.dll
using System.Net;               // WebClient / HttpClient

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before:PDFmyURL— either plain HttpClient/WebClient against pdfmyurl.com/api,
// or the optional .NET component:
using PDFmyURLdotNET;          // only if you used PDFmyURL.NET.dll
using System.Net;               // WebClient / HttpClient

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Etapa 3: Inicializar a licença

Adicionar inicialização de licença na inicialização do aplicativo:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Exemplos de migração de código

Converter URLs em PDF

A operação de conversão de URL para PDF demonstra as diferenças fundamentais entre as APIs doPDFmyURLe do IronPDF.

Abordagem do PDFmyURL:

//PDFmyURLREST API — no NuGet SDK. Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string url = "https://example.com";

        try
        {
            using (var client = new WebClient())
            {
                client.QueryString.Add("license", license);
                client.QueryString.Add("url", url);
                // PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

//PDFmyURLREST API — no NuGet SDK. Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string url = "https://example.com";

        try
        {
            using (var client = new WebClient())
            {
                client.QueryString.Add("license", license);
                client.QueryString.Add("url", url);
                // PDF binary is returned in the response body
                client.DownloadFile("https://pdfmyurl.com/api", "output.pdf");
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Abordagem IronPDF:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

PDFmyURL exige a abertura de uma conexão HTTP para https://pdfmyurl.com/api em toda conversão, anexando o token license mais o alvo url como parâmetros da consulta (ou formulário), e escrevendo o corpo da resposta em disco. Os erros surgem como WebException com base no código de status HTTP.

IronPDF simplifica isso em três linhas: criar um ChromePdfRenderer, chamar RenderUrlAsPdf(), e usar o método embutido SaveAs(). Nenhuma credencial por requisição é necessária — a licença é configurada uma vez no início da aplicação.

Para cenários avançados de URL para PDF, consulte a documentação de URL para PDF .

Convertendo strings HTML em PDF

A conversão de strings HTML mostra claramente as diferenças de padrão.

Abordagem do PDFmyURL:

//PDFmyURLREST API — no NuGet SDK. Send the raw HTML in the `html` parameter.
// Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = "<html><body><h1>Hello World</h1></body></html>";

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license", license },
                    { "html", html }
                };
                // POST form-encoded; response body is the PDF binary
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

//PDFmyURLREST API — no NuGet SDK. Send the raw HTML in the `html` parameter.
// Docs: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = "<html><body><h1>Hello World</h1></body></html>";

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license", license },
                    { "html", html }
                };
                // POST form-encoded; response body is the PDF binary
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Abordagem IronPDF:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        string 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;

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

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports System

Class Example
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

PDFmyURL envia o HTML bruto no parâmetro de formulário html para seu endpoint API e retorna o PDF renderizado como o corpo da resposta. O RenderHtmlAsPdf() do IronPDF processa tudo localmente usando o mecanismo de renderização Chromium.

Consulte o guia de conversão de HTML para PDF para obter opções adicionais.

Conversão de arquivos HTML com configurações de página

A configuração do tamanho, orientação e margens do papel requer abordagens diferentes em cada biblioteca.

Abordagem do PDFmyURL:

//PDFmyURLREST API — no NuGet SDK. Page settings are sent as query/form parameters.
// Parameter reference: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = File.ReadAllText("input.html");

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license",     license },
                    { "html",        html },
                    { "page_size",   "A4" },
                    { "orientation", "landscape" },
                    { "top",         "10" },
                    { "unit",        "mm" }
                };
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

//PDFmyURLREST API — no NuGet SDK. Page settings are sent as query/form parameters.
// Parameter reference: https://pdfmyurl.com/html-to-pdf-api
using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;

class Example
{
    static void Main()
    {
        string license = "your-license-key";
        string html = File.ReadAllText("input.html");

        try
        {
            using (var client = new WebClient())
            {
                var values = new NameValueCollection
                {
                    { "license",     license },
                    { "html",        html },
                    { "page_size",   "A4" },
                    { "orientation", "landscape" },
                    { "top",         "10" },
                    { "unit",        "mm" }
                };
                byte[] pdfBytes = client.UploadValues("https://pdfmyurl.com/api", "POST", values);
                File.WriteAllBytes("output.pdf", pdfBytes);
            }
        }
        catch (WebException ex)
        {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Abordagem IronPDF:

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}

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

class Example
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Example
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

PDFmyURL configura páginas adicionando parâmetros de formulário como page_size=A4, orientation=landscape, e os campos de margem (top, bottom, left, right) junto com um unit (por exemplo, mm, in).IronPDF fornece propriedades fortemente tipadas por meio de RenderingOptions com enums como PdfPaperSize.A4 e valores inteiros para margens em milímetros.

Referência de mapeamento da APIPDFmyURLpara o IronPDF

Este mapeamento acelera a migração ao mostrar equivalentes diretos da API:

Classes Centrais / Pontos de Entrada

Métodos

Opções de configuração

As configurações doPDFmyURLsão passadas como parâmetros de formulário/consulta na solicitação HTTP. A tabela abaixo mapeia nomes reais de parâmetrosPDFmyURLpara RenderingOptions do IronPDF.

Comparação de Autenticação

Problemas e soluções comuns em migrações

Questão 1: Token de Licença vs Chave de Licença

PDFmyURL: Requer o token license em toda solicitação de API.

Solução: Defina a licença do IronPDF uma única vez na inicialização do aplicativo:

// PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs

// PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key");

// IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Set once, typically in Program.cs or Startup.cs

' PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key")

' IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Set once, typically in Program.vb or Startup.vb

' PDFmyURL: license token per request
client.QueryString.Add("license", "your-license-key")

' IronPDF: One-time license at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
' Set once, typically in Program.vb or Startup.vb

Problema 2: Sintaxe de espaço reservado em cabeçalhos/rodapés

PDFmyURL: Usa tokens como [page] e [topage] dentro dos parâmetros de formulário header / footer (consulte a referência de API ao vivo para a lista canônica de tokens).

Solução: Atualize para o formato placeholder do IronPDF dentro de HtmlHeaderFooter.HtmlFragment:

// PDFmyURL: "Page [page] of [topage]"
// IronPDF: "Page {page} of {total-pages}"

// PDFmyURL: "Page [page] of [topage]"
// IronPDF: "Page {page} of {total-pages}"

' PDFmyURL: "Page [page] of [topage]"
' IronPDF: "Page {page} of {total-pages}"

' PDFmyURL: "Page [page] of [topage]"
' IronPDF: "Page {page} of {total-pages}"

Edição 3: Padrões Assíncronos

PDFmyURL: É uma chamada HTTP remota; normalmente invocado com HttpClient.PostAsync contra pdfmyurl.com/api.

**Solução:**IronPDF é in-processo e síncrono por padrão; Se necessário, encapsule para async:

// PDFmyURL: HTTP request to the public endpoint
var response = await http.PostAsync("https://pdfmyurl.com/api", form);

// IronPDF: Sync by default, wrap for async
var pdf = await Task.Run(() => renderer.RenderUrlAsPdf(url));

// PDFmyURL: HTTP request to the public endpoint
var response = await http.PostAsync("https://pdfmyurl.com/api", form);

// IronPDF: Sync by default, wrap for async
var pdf = await Task.Run(() => renderer.RenderUrlAsPdf(url));

Imports System.Net.Http
Imports System.Threading.Tasks

' PDFmyURL: HTTP request to the public endpoint
Dim response = Await http.PostAsync("https://pdfmyurl.com/api", form)

' IronPDF: Sync by default, wrap for async
Dim pdf = Await Task.Run(Function() renderer.RenderUrlAsPdf(url))

Imports System.Net.Http
Imports System.Threading.Tasks

' PDFmyURL: HTTP request to the public endpoint
Dim response = Await http.PostAsync("https://pdfmyurl.com/api", form)

' IronPDF: Sync by default, wrap for async
Dim pdf = Await Task.Run(Function() renderer.RenderUrlAsPdf(url))

Problema 4: Tratamento de erros

PDFmyURL: Falhas de nível HTTP (licença inválida, limite de taxa, erro de rede, serviço indisponível) surgem como WebException / códigos de status de não-sucesso.

Solução: Atualizar blocos de captura para exceções tipadas do IronPDF:

// PDFmyURL: WebException from the HTTP call
catch (WebException e) { ... }

// IronPDF: Typed exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }

// PDFmyURL: WebException from the HTTP call
catch (WebException e) { ... }

// IronPDF: Typed exceptions
catch (IronPdf.Exceptions.IronPdfRenderingException e) { ... }

net

net

Questão 5: Padrão de Configuração

PDFmyURL: A configuração é passada como parâmetros de formulário/query na requisição HTTP.

Solução: Utilize propriedades RenderingOptions fortemente tipadas:

// PDFmyURL: form/query parameters
values.Add("page_size", "A4");
values.Add("orientation", "landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

// PDFmyURL: form/query parameters
values.Add("page_size", "A4");
values.Add("orientation", "landscape");

// IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;

' PDFmyURL: form/query parameters
values.Add("page_size", "A4")
values.Add("orientation", "landscape")

' IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape

' PDFmyURL: form/query parameters
values.Add("page_size", "A4")
values.Add("orientation", "landscape")

' IronPDF: Properties with enums
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape

Lista de verificação para migração do PDFmyURL

Tarefas pré-migração

Faça uma auditoria em seu código-fonte para identificar todos os usos do PDFmyURL:

# FindPDFmyURLendpoint and component usage
grep -r "pdfmyurl.com/api\|PDFmyURLdotNET\|new PDFmyURL(" --include="*.cs" .

# Find license-token references
grep -r "license=\|licensekey" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "\[page\]\|\[topage\]" --include="*.cs" .

# FindPDFmyURLendpoint and component usage
grep -r "pdfmyurl.com/api\|PDFmyURLdotNET\|new PDFmyURL(" --include="*.cs" .

# Find license-token references
grep -r "license=\|licensekey" --include="*.cs" --include="*.json" --include="*.config" .

# Find placeholder patterns to migrate
grep -r "\[page\]\|\[topage\]" --include="*.cs" .

Documentar parâmetros de configuração atuais usados (tamanho_da_página, orientação, margens, cabeçalho/rodapé, etc.). Planeje o armazenamento da chave de licença usando variáveis ​​de ambiente.

Tarefas de atualização de código

1. Remova a referência opcional PDFmyURL.NET.dll se você a usou (não existe pacote NuGet para desinstalar)
2. Instalar o pacote NuGet do IronPDF
3. Atualize todas as importações de namespace
4. Substitua o token license por IronPdf.License.LicenseKey em cada solicitação
5. Converta parâmetros de formulário/consulta para propriedades RenderingOptions
6. Atualize a sintaxe do placeholder em cabeçalhos/rodapés (por exemplo, [page] → {page}, [topage] → {total-pages})
7. Atualize o código de tratamento de erro (WebException → excepciones tipadas de IronPDF)
8. Adicionar inicialização da licença do IronPDF na inicialização do sistema.

Testes pós-migração

Após a migração, verifique os seguintes aspectos:

• A qualidade de saída do PDF de teste corresponde às expectativas.
• Verificar se os padrões assíncronos funcionam corretamente.
• Comparar a fidelidade da renderização com a saída anterior.
• Teste se todas as variações do modelo são renderizadas corretamente.
• Validar configurações da página (tamanho, orientação, margens)
• Instale as dependências do Linux se estiver implantando em servidores Linux.

Principais benefícios da migração para o IronPDF

A migração doPDFmyURLpara o IronPDF oferece diversas vantagens importantes:

Privacidade total: os documentos nunca saem do seu servidor. Todo o processamento ocorre localmente, eliminando preocupações com a segurança de dados para conteúdo sensível.

Custo único: A opção de licença perpétua elimina as taxas de assinatura recorrentes. Chega de pagamentos mensais, independentemente do volume de uso.

Funcionamento offline: Funciona sem internet após a configuração inicial. Interrupções de rede não afetam a geração de PDFs.

Sem limites de taxa: processe um número ilimitado de documentos sem se preocupar com limitações de velocidade.

Menor latência: Sem sobrecarga de rede, as conversões ficam mais rápidas, especialmente para aplicações de alto volume.

Controle total: você controla o ambiente de processamento, não um serviço de terceiros.

Mecanismo Chromium moderno: suporte completo a CSS3 e JavaScript com o mesmo mecanismo de renderização que alimenta o navegador Chrome.

Desenvolvimento Ativo: As atualizações regulares do IronPDF garantem compatibilidade com versões modernas do .NET.