QuestPDF è eccellente quando C# è il confine di prodotto
QuestPDF merita un confronto rispettoso. È una libreria moderna di generazione PDF per sviluppatori C#, con API fluida, tipizzazione forte, documentazione ampia, Companion App per anteprima e debug e un modello di licenza insolitamente chiaro per un PDF SDK.
La domanda di prodotto non è “quale dei due può creare un PDF?”. Entrambi possono. La domanda utile è dove deve vivere il confine PDF: dentro un’applicazione .NET che possiede impaginazione, byte e ciclo di vita, oppure come servizio infrastrutturale chiamato da più prodotti e linguaggi.
Guida rapida alla scelta
- Scegliete QuestPDF quando C# è la fonte di riferimento del documento, l’app deve girare offline o vi servono operazioni locali su PDF esistenti.
- Scegliete gPdf quando un unico livello PDF deve servire Node, Python, Go, .NET, job e sistemi regionali tramite la stessa API HTTP.
- Scegliete gPdf quando le modifiche di impaginazione devono essere revisioni di modello, non ricompilazioni C# e ridistribuzioni di servizio.
Stessa famiglia documentale, diverso modello di proprietà
Con QuestPDF l’applicazione possiede la generazione PDF, e questo è un vero punto di forza: C# resta vicino al modello di dominio, gira e si debuga in locale, senza chiamate durante l’esecuzione a un’API esterna.
La contropartita è che il team possiede anche il resto della superficie di produzione:
- CPU e memoria per generare.
- Scoperta font e sostituzione in ogni ambiente di distribuzione.
- Integrazione libreria codici a barre e QA di stampa.
- Dipendenze native e distribuzione per grafici o grafica personalizzata.
- Monitoraggio, nuovi tentativi e gestione errori.
- Distribuzione regionale quando utenti o magazzini sono globali.
- Rilasci ogni volta che cambia l’impaginazione del documento.
Con gPdf, quella superficie si sposta fuori dall’applicazione: l’app invia un DocumentRequest o template_id + data, e il servizio si assume generatore, ambiente sull’edge, font, primitive per codici a barre, output PDF/A e pacchetto di fattura elettronica. È meno attraente se volete ogni dettaglio in C#, più attraente se la generazione PDF deve essere un livello di utilità chiamabile da qualunque architettura.
Tre compromessi che un’API ospitata deve dichiarare chiaramente
Molte presentazioni “libreria vs API” saltano le tre domande che un architetto .NET chiede per prime. Un confronto corretto le risponde apertamente.
1. Dove vanno i dati del documento. Questa pagina parla in gran parte di fatture, estratti e fatture elettroniche: documenti pieni di nomi, indirizzi, codici fiscali, partite IVA e importi. Con QuestPDF quei byte vengono costruiti dentro il vostro processo e non escono. L’API pubblica gPdf trasmette i dati della richiesta al generatore, ma il generatore è senza conservazione: il JSON della richiesta resta in un isolate V8 di Cloudflare Workers solo per la generazione (~4 ms tipici) e viene rilasciato quando la risposta completa; non viene mai archiviato, registrato, campionato o usato per addestramento, con log operativi limitati a stato HTTP e durata (security, DPA). Scelta di residenza dati UE / globale e distribuzione enterprise on-prem / privata riducono o chiudono ulteriormente l’esposizione. Detto questo, mantenere la generazione nel processo senza configurazione è una ragione legittima, a volte decisiva, per cui un team finanziario o del settore pubblico sceglie QuestPDF.
2. Modalità di errore. Una libreria non ha una terza parte che può andare giù; la generazione può fallire solo sull’infrastruttura che già possedete. Un’API ospitata aggiunge una dipendenza di disponibilità che non controllate. Il modo corretto di adottare gPdf è trattare le chiamate di generazione come qualunque chiamata esterna: tempi limite, nuovi tentativi, coda e idealmente una modalità degradata. Se la generazione documentale sta su un percorso sincrono critico, pesate “gestirla voi” contro “dipendere dallo SLA di un fornitore”.
3. Profilo di latenza. La generazione nel processo è una chiamata di funzione senza rete. Una chiamata ospitata è un’andata e ritorno di rete. Per job batch e asincroni è rumore. Per “l’utente clicca e il PDF deve apparire subito”, stare nel processo è strutturalmente più veloce: i PoP sull’edge di gPdf rendono il salto piccolo, ma resta comunque TLS più andata e ritorno; QuestPDF è una chiamata di metodo.
Nessuno di questi punti rende gPdf la scelta sbagliata; definiscono quando è quella giusta: team i cui dati documentali possono uscire dal processo, i cui flussi tollerano un passaggio di rete e che preferiscono dipendere dalla disponibilità di un fornitore invece di gestire una flotta di generatori.
Modello di licenza e prezzo
La pagina pubblica di licenza QuestPDF dice che una licenza commerciale è richiesta solo per aziende sopra 1 milione USD di ricavi lordi annui. Il livello Community è gratuito per individui idonei, progetti open source, non-profit e aziende sotto quella soglia, con termini MIT. La stessa pagina pubblica elenca due livelli commerciali perpetui: Professional a 999 USD più imposte locali per team fino a 10 sviluppatori, ed Enterprise a 2.999 USD più imposte locali per tutta l’organizzazione, senza conteggio sviluppatori. Entrambi includono un anno di aggiornamenti e progetti, server e distribuzioni illimitati, e la licenza non scade mai per l’ultima versione ricevuta.
Anche il modello di applicazione è insolitamente leggero. La licenza si imposta con una sola riga, QuestPDF.Settings.License = LicenseType.Community;, senza chiave di licenza, server di attivazione e, secondo la pagina di configurazione di QuestPDF, senza chiamate di rete né dati che lasciano la macchina. È un modello basato sulla fiducia: selezionate il livello per cui siete idonei. Non c’è una fattura fornitore per documento, e una licenza pagata gira ovunque, anche completamente offline.
gPdf applica il prezzo direttamente al servizio di generazione. Il piano pubblico Basic parte da 5 USD/mese per 100.000 pagine, con eccedenza da 0,00005 USD per pagina. È una fattura fornitore, ma rimuove anche il progetto separato di gestire la generazione PDF: nessun cluster di generazione, nessun percorso di distribuzione NuGet, nessun pool caldo regionale, nessun pacchetto font per app e nessun servizio PDF da patchare.
Quindi il confronto dei costi non è “999 USD contro 5 USD”: la licenza è la riga piccola. Il confronto reale è:
Totale QuestPDF = licenza (una tantum) + vostro hosting + tempo ingegneri + reperibilità
Totale gPdf = fattura per pagine (infrastruttura, font, scalabilità e presenza sull'edge incluse)Con il calcolo pubblico per pagina, l’eccedenza gPdf è 0,05 USD ogni 1.000 pagine (50 USD per 1 milione, 500 USD per 10 milioni). Una licenza Enterprise una tantum da 2.999 USD va in pareggio con quel conto solo intorno a ~60 milioni di pagine, e quel calcolo ignora hosting e mesi-ingegnere di QuestPDF, che spostano il vero punto di pareggio molto più avanti a favore di gPdf salvo che abbiate già un’infrastruttura di generazione quasi gratuita. Regola pratica: se dovreste costruire e presidiare un servizio di generazione solo per usare la libreria, gPdf di solito vince sul costo totale molto prima che il conto per pagina raggiunga la licenza; se quell’infrastruttura esiste già ed è quasi gratuita per voi, la licenza perpetua vince su larga scala.
Flusso di sviluppo: C# fluido o modelli
L’API fluida di QuestPDF è adatta quando gli sviluppatori possiedono la forma del documento. Tipizzazione forte, catene di metodi, componenti C# riutilizzabili, rifattorizzazioni nell’IDE e Companion App hanno senso quando il PDF fa parte del codice applicativo.
gPdf si adatta a un flusso diverso. Gli sviluppatori possono ancora scrivere JSON direttamente, ma i sistemi di produzione di solito si spostano verso modelli. Un designer, operatore o ingegnere regola l’impaginazione in gPdf Studio. L’impaginazione approvata diventa un modello, e il servizio server continua a generare con template_id + data.
Questa differenza pesa quando il documento cambia spesso. Se cambia un’etichetta corriere, una fattura, una bolla di accompagnamento o un estratto, gPdf può mantenere stabile l’ambiente di esecuzione mentre si muove solo il modello. Con QuestPDF l’impaginazione è codice C#, quindi il percorso normale è modifica codice, test, build, distribuzione e piano di rollback.
Nessun flusso è universalmente migliore: QuestPDF ottimizza per sviluppatori C# che vogliono il documento come codice; gPdf per modelli operativi condivisi tra sistemi.
Conformità: entrambi i prodotti sono seri
Questo non è un confronto in cui gPdf vince dicendo che il concorrente non ha funzionalità di conformità. Il materiale pubblico attuale di QuestPDF elenca supporto forte agli standard, inclusi PDF/A, PDF/UA-1 e fatturazione elettronica EN 16931 tramite un esempio ZUGFeRD 2.1 / Factur-X basato sullo standard UN/CEFACT Cross Industry Invoice (CII). L’esempio imposta PdfA = true, incorpora il file factur-x.xml con AddAttachment(), estende il documento con metadati XMP e valida il risultato con veraPDF (per PDF/A-3b) e Mustang Project (per ZUGFeRD). È una ricetta completa e onesta, e la vostra pipeline possiede ogni passaggio.
gPdf impacchetta gli stessi standard come contratto API. JSON Render espone sei profili PDF/A (1b, 2b, 3b, 4, 2u, 3u) più PDF/UA-1 tramite settings.profile, Template Render riusa lo stesso modello documento, ed E-Invoice Render espone la rotta dedicata POST /api/v1/e-invoice/render che produce pacchetti Factur-X / ZUGFeRD PDF/A-3b con XML CII EN 16931 incorporato. La differenza rispetto alla ricetta QuestPDF è cosa fa il servizio per voi: gPdf esegue lato servizio la validazione PDF/A-3b e fattura elettronica, supporta consegna sincrona diretta o tramite oggetto da interrogare, e offre residenza dati UE o globale come impostazioni richiesta invece che come passaggi da assemblare e gestire. QuestPDF è adatto quando quella validazione deve vivere dentro la vostra pipeline .NET; gPdf quando deve essere un contratto ospitato condiviso da molti sistemi.
Font e codici a barre: il vero confronto è lo sforzo di integrazione
QuestPDF ha un modello font capace. Include Lato 2.015 di default, carica automaticamente font di sistema e della directory di distribuzione, permette di registrare font personalizzati tramite FontManager e supporta catene di sostituzione. Questo dà controllo agli sviluppatori. Ma la stessa documentazione è schietta sul punto debole: “in most cloud deployments, few or no fonts are available, which may lead to unexpected results,” e raccomanda di disabilitare i font dell’ambiente e registrare esplicitamente ciò che serve. In altre parole, su container o destinazioni serverless l’ambiente font è vostro da pianificare, spedire e testare; un glifo mancante diventa un carattere segnaposto oppure, se abilitate CheckIfAllTextGlyphsAreAvailable, un’eccezione.
gPdf rende i font parte del confine di servizio. Il generatore include un set per più sistemi di scrittura: latino, greco, cirillico, arabo, ebraico, bengalese, tamil, thai, vietnamita, monospace e CJK con sostituzione per script verso Noto KR / JP / SC. Risolve le scelte silenziose con selezione automatica implicita, e le scelte esplicite con prefer o strict. I chiamanti non spediscono un font CJK, non registrano asset Noto in un’app .NET e non tarano la sostituzione per ogni destinazione di distribuzione. Inviano dati; il generatore si assume l’ambiente font, uguale in ogni regione.
Il confronto sui codici a barre ha forma simile. La documentazione sui codici a barre di QuestPDF mostra un approccio solido con ZXing.Net generato come SVG vettoriale, e nota esplicitamente che ZXing.Net non è incluso nel pacchetto QuestPDF: lo installate da NuGet e lo cablate:
// QuestPDF: add the separate ZXing.Net package, encode, render to SVG, embed.
// dotnet add package ZXing.Net
var writer = new ZXing.BarcodeWriterSvg {
Format = ZXing.BarcodeFormat.CODE_128,
Options = new ZXing.Common.EncodingOptions { Width = 320, Height = 80 }
};
string svg = writer.Write("INV-2026-001").Content;
container.Svg(svg);
// GS1-128 with Application Identifiers and FNC1 framing is hand-wired on top.Con gPdf, la generazione dei codici a barre è un elemento dello schema di prima classe. La richiesta dichiara formato, contenuto, dimensione fisica e una riga leggibile opzionale; i formati GS1 sono nativi, quindi gli identificatori di applicazione vanno direttamente in content:
{
"type": "barcode",
"format": "gs1_128",
"content": "(01)00012345678905(21)SN12345",
"x": 12, "y": 60, "width": 80, "height": 18,
"barcode_text": { "enabled": true, "position": "bottom" }
}Per una singola app .NET, installare ZXing.Net e testare l’output può essere facile. Per molti servizi e modelli, soprattutto carichi logistici e retail che richiedono GS1-128, SSCC, GTIN, GS1 DataMatrix o GS1 QR con riga leggibile, spostare il comportamento dei codici a barre dentro l’API documento è più semplice da mantenere che ricablare ZXing in ogni servizio.
Dove QuestPDF vince chiaramente
Oltre a girare offline, mantenere i dati documentali dentro il vostro perimetro (coperto sopra) e ai casi in cui il codice PDF stesso è parte del prodotto, cioè quando un team deve ispezionare, estendere o possedere il percorso di generazione, QuestPDF ha due aree di capacità chiaramente fuori dall’ambito di gPdf:
- Operazioni su PDF esistenti. QuestPDF può caricare file esistenti e unirli, selezionare / riordinare / invertire / filtrare pagine, applicare overlay, aggiungere allegati, impostare metadati XMP, linearizzare per consegna web e sia cifrare sia decifrare con sicurezza 40/128/256-bit. gPdf può proteggere con password e permessi i PDF che genera, ma non apre, unisce o decifra file che non ha creato.
- Grafici, mappe e grafica personalizzata. QuestPDF integra librerie di grafici (ScottPlot, LiveCharts, Microcharts), incorpora mappe Mapbox ed espone un Canvas SkiaSharp per disegno 2D arbitrario. gPdf può disegnare grafica vettoriale con l’elemento
path(dati SVG path) o incorporare un grafico SVG / PNG prodotto a monte, ma non ha motore grafici, mappe o Canvas integrati; se grafici guidati dai dati sono centrali, quella strumentazione vive meglio con QuestPDF.
Dove gPdf vince chiaramente
gPdf vince quando un’organizzazione non vuole che ogni team prodotto possieda il proprio servizio PDF: architetture poliglotte, flussi globali e sistemi ERP / OMS / WMS / e-commerce / fintech / ticketing che generano documenti da dati strutturati, con modelli che cambiano indipendentemente dal codice. In questi ambienti una libreria locale spesso parte economica e diventa una flotta: un servizio per linguaggio, un percorso di distribuzione per regione, un piano font per container, una suite di regressioni codici a barre per team. gPdf trasforma quella flotta in un unico contratto HTTP.
Serverless rende il confine più chiaro. Su AWS Lambda, Cloud Run o Azure Functions, QuestPDF gira comunque dentro l’applicazione: il team impacchetta ambiente .NET, font, dipendenze native e CPU / memoria sufficienti per il picco PDF, e possiede gli avvii a freddo. gPdf è già il servizio di generazione: la funzione invia una piccola richiesta template_id + data sull’edge e riceve byte PDF, senza generatore da scaldare o worker regionale da scalare.
Forma della migrazione
La migrazione da QuestPDF a gPdf non è una riscrittura riga per riga. È un cambio di confine: il codice C# che costruisce il PDF diventa una richiesta documento JSON oppure un modello pubblicato.
Prima / dopo — la chiamata C# che costruisce il documento si riduce a un POST HTTP (clic per espandere)
- // Before: generate the PDF inside a .NET application.
- Document.Create(container =>
- {
- container.Page(page =>
- {
- page.Size(PageSizes.A4);
- page.Margin(30);
- page.Header().Text("Invoice").FontSize(24).SemiBold();
- page.Content().Column(column =>
- {
- column.Item().Text($"Invoice number: {invoice.Number}");
- column.Item().Text($"Total: {invoice.Total:C}");
- });
- });
- })
- .GeneratePdf("invoice.pdf");
+
+ // After: render through the shared gPdf template from C#.
+ using System.Net.Http.Headers;
+ using System.Net.Http.Json;
+
+ using var client = new HttpClient();
+ client.DefaultRequestHeaders.Authorization =
+ new AuthenticationHeaderValue("Bearer", key);
+
+ var response = await client.PostAsJsonAsync(
+ "https://api.gpdf.com/api/v1/template-render",
+ new {
+ template_id = "invoice-v2",
+ data = new {
+ invoice_number = invoice.Number,
+ total = invoice.Total,
+ currency = invoice.Currency
+ }
+ });
+
+ response.EnsureSuccessStatusCode();
+ byte[] pdfBytes = await response.Content.ReadAsByteArrayAsync();Dopo lo spostamento del confine, le modifiche di impaginazione possono diventare revisioni di modello invece di distribuzioni applicative. L’applicazione continua a possedere dati aziendali e decisioni di processo; gPdf si assume la generazione.
Nota su prezzi e fonti
Le informazioni QuestPDF in questa pagina sono state verificate il 2026-06-02 su fonti ufficiali QuestPDF: License and Pricing, License configuration, Features Overview, Companion App features, Barcodes, Font management e ZUGFeRD example. Prezzi e pagine funzionalità possono cambiare; i team acquisti dovrebbero ricontrollare la pagina del fornitore prima di una decisione d’acquisto. QuestPDF e i marchi collegati appartengono ai rispettivi proprietari, e questo confronto non è approvato da loro.
Scenari correlati di generazione PDF
I team che confrontano QuestPDF e gPdf di solito stanno decidendo se possedere una libreria C# locale o usare un livello PDF condiviso. Per i carichi strutturati, partite da API da JSON a PDF, API PDF per fatture e API codici a barre GS1. Per requisiti di conformità, leggete API PDF/A, API ZUGFeRD e API Factur-X. Per etichette operative, vedete API PDF per etichette di spedizione.
FAQ
gPdf sostituisce QuestPDF?
No. gPdf sostituisce la necessità di gestire un servizio di generazione PDF per documenti aziendali strutturati. QuestPDF resta una forte libreria C# locale quando il PDF deve essere generato dentro l’applicazione.
QuestPDF è gratuito?
La pagina pubblica di licenza QuestPDF dice che il livello Community è gratuito con termini MIT per individui idonei, progetti open source, non-profit e aziende sotto 1 milione USD di ricavi lordi annui. Le aziende sopra quella soglia hanno bisogno di una licenza commerciale perpetua: Professional a 999 USD più imposte locali per un massimo di 10 sviluppatori, oppure Enterprise a 2.999 USD più imposte locali per tutta l’organizzazione, ciascuna con un anno di aggiornamenti incluso.
gPdf può generare grafici o mappe come QuestPDF?
Non come motore integrato. QuestPDF integra librerie di grafici (ScottPlot, LiveCharts, Microcharts), mappe Mapbox e un Canvas SkiaSharp che genera dentro il documento. gPdf può comunque disegnare grafici vettoriali con l’elemento path (che accetta dati SVG path) e forme, oppure incorporare come image un SVG / PNG prodotto da qualunque libreria grafici. La differenza è che QuestPDF calcola e genera il grafico nel processo, mentre con gPdf producete voi l’arte del grafico e gPdf la posiziona. Se grafici guidati dai dati o mappe sono centrali per il documento, QuestPDF è più adatto.
Quale prodotto costa meno?
Dipende dal confine. QuestPDF può costare meno per team .NET idonei ai termini Community o che gestiscono già l’infrastruttura di generazione. gPdf può costare meno quando l’alternativa è costruire, ospitare e mantenere un servizio PDF attraverso prodotti o regioni.
gPdf archivia o registra i dati dei miei documenti?
No. Il JSON che inviate e il PDF che gPdf restituisce non vengono archiviati. Ogni richiesta genera dentro un singolo isolate V8 di Cloudflare Workers, resta in memoria solo per la generazione, circa 4 ms tipici, e viene rilasciata quando lo stream di risposta completa; gPdf non conserva, registra, campiona o usa per addestramento il contenuto DocumentRequest. I log operativi tengono solo stato HTTP e durata per 30 giorni e non contengono corpi richiesta. Vedete security policy, privacy policy e DPA. Per carichi che non possono trasmettere dati in alcun modo, la distribuzione on-prem / privata li mantiene dentro il vostro perimetro.
QuestPDF può funzionare senza accesso a Internet?
Sì. La pagina di configurazione licenza di QuestPDF dice che non c’è chiave di licenza o server di attivazione, e che i calcoli sono eseguiti localmente. È una delle ragioni più chiare per scegliere QuestPDF.
gPdf può generare impaginazioni C# QuestPDF arbitrarie?
No. gPdf non esegue codice di impaginazione C#. Migrare significa convertire la forma del documento in una richiesta JSON gPdf o in un modello gPdf salvato.