QuestPDF is uitstekend wanneer C# de productgrens is
QuestPDF verdient een respectvolle vergelijking. Het is een moderne PDF-generatiebibliotheek voor C#-ontwikkelaars, met een fluent API, sterke typing, veel documentatie, een Companion App voor preview en debugging en een licentiemodel dat voor een PDF-SDK opvallend helder is.
De productvraag is niet “welke kan een PDF maken?”. Dat kunnen ze allebei. De nuttige vraag is waar de PDF-grens hoort te liggen: binnen een .NET-applicatie die lay-out, bytes en levenscyclus bezit, of als infrastructuurservice die door meerdere producten en talen wordt aangeroepen.
Snelle beslisgids
- Kies QuestPDF wanneer C# de leidende bron voor het document is, de app offline moet draaien of u lokale operaties op bestaande PDF’s nodig hebt.
- Kies gPdf wanneer één PDF-laag Node, Python, Go, .NET, jobs en regionale systemen via dezelfde HTTP API moet bedienen.
- Kies gPdf wanneer lay-outwijzigingen sjabloonrevisies moeten zijn, geen C# rebuilds en service redeploys.
Dezelfde documentfamilie, ander eigenaarschap
Met QuestPDF bezit de applicatie PDF-generatie — een echte kracht: C# blijft dicht bij uw domeinmodel, lokaal draaien en debuggen, zonder runtime-aanroep naar een externe API.
De keerzijde is dat uw team ook de rest van het productieoppervlak bezit:
- CPU en geheugen voor rendering.
- Fontdetectie en fontterugval in elke implementatieomgeving.
- Barcodebibliotheekintegratie en print-QA.
- Native pakketten en uitrolzorgen voor grafieken of maatwerkgrafiek.
- Monitoring, retries en storingsafhandeling.
- Regionale uitrol wanneer gebruikers of magazijnen wereldwijd zijn.
- Uitrolmomenten wanneer de documentlay-out verandert.
Met gPdf verhuist dat deel naar buiten: de applicatie stuurt een DocumentRequest of template_id + data, en de service bezit de renderengine, edge-runtime, fonts, barcodeprimitieven, PDF/A-output en e-factuurverpakking. Minder aantrekkelijk als u elk detail in C# wilt houden, aantrekkelijker als PDF-generatie een gedeelde hulplaag moet zijn die vanuit elke stack te gebruiken is.
Drie trade-offs waarop een gehoste API eerlijk moet antwoorden
De meeste “bibliotheek vs API”-pitches slaan de drie vragen over die een .NET-architect als eerste stelt. Een eerlijke vergelijking zegt ze hardop.
1. Waar de documentdata heen gaat. Deze pagina gaat vooral over facturen, overzichten en e-facturen — documenten vol namen, adressen, belastingnummers en bedragen. Met QuestPDF worden die bytes binnen uw proces opgebouwd en verlaten ze het niet. De publieke gPdf API verzendt de documentdata naar de renderengine, maar de renderengine bewaart niets: request-JSON wordt alleen tijdens de render in een Cloudflare Workers V8-isolate gehouden (typisch ~4 ms) en vrijgegeven wanneer de response klaar is — nooit opgeslagen, gelogd, gesampled of gebruikt voor training; operationele logs zijn beperkt tot HTTP-status en duur (security, DPA). EU / wereldwijde dataresidentiekeuze en enterprise on-prem / privé-implementatie verkleinen of sluiten de blootstelling verder. Toch is in-process genereren zonder extra inrichting een legitieme — soms beslissende — reden waarom een financieel of publiek-sector-team QuestPDF kiest.
2. De storingsmodus. Een bibliotheek heeft geen derde partij die kan uitvallen; generatie kan alleen falen op infrastructuur die u al bezit. Een gehoste API voegt een beschikbaarheidsafhankelijkheid toe die u niet controleert. De juiste manier om gPdf te adopteren is renderaanroepen behandelen als elke externe call — timeout, retry, queue en liefst een terugvalpad voor beperkte werking. Als documentgeneratie op een kritisch synchroon pad zit, weeg dan “zelf beheren” af tegen “afhankelijk zijn van de beschikbaarheid van een leverancier”.
3. Het latentieprofiel. In-process generatie is een functieaanroep zonder netwerk. Een gehoste call is een netwerk-roundtrip. Voor batch- en async jobs is dat ruis. Voor “de gebruiker klikt en de PDF moet nu verschijnen” is in-process structureel sneller — gPdf’s edge PoP’s maken de hop klein, maar het blijft TLS plus een roundtrip, terwijl QuestPDF een methodeaanroep is.
Geen van deze punten maakt gPdf de verkeerde keuze; ze definiëren wanneer het de juiste is — voor teams waarvan documentdata het proces mag verlaten, waarvan werkwijzen een netwerkhop verdragen en die liever afhankelijk zijn van leveranciersbeschikbaarheid dan zelf een rendervloot beheren.
Licenties en prijsmodel
De publieke licentiepagina van QuestPDF zegt dat een commerciële licentie alleen vereist is voor bedrijven boven 1 miljoen USD jaarlijkse bruto-omzet. De Community-tier is gratis onder MIT-voorwaarden voor in aanmerking komende personen, open-sourceprojecten, non-profits en bedrijven onder die omzetgrens. Dezelfde publieke pagina noemt twee eeuwigdurende commerciële licentieniveaus: Professional voor 999 USD plus lokale belasting voor teams tot 10 ontwikkelaars, en Enterprise voor 2.999 USD plus lokale belasting voor de hele organisatie zonder ontwikkelaars te tellen. Beide bevatten één jaar updates en onbeperkte projecten, servers en deployments, en de licentie verloopt nooit voor de laatst ontvangen versie.
Het handhavingsmodel is ook ongebruikelijk licht. De licentie wordt ingesteld met één regel — QuestPDF.Settings.License = LicenseType.Community; — zonder licentiesleutel, activatieserver en, volgens QuestPDF’s eigen configuratiepagina, zonder netwerkoproepen en zonder data die de machine verlaat. Het is een vertrouwensmodel: u kiest de tier waarvoor u in aanmerking komt. Er is geen leveranciersrekening per document, en een betaalde licentie draait overal, inclusief volledig offline.
gPdf prijst de generatieservice direct. Het publieke Basic-plan begint bij 5 USD/maand voor 100.000 pagina’s, met meerprijs vanaf 0,00005 USD per pagina. Dat is een leveranciersrekening, maar het haalt ook het aparte project weg om PDF-generatie zelf te beheren: geen rendercluster, geen NuGet-uitrolpad, geen regionale warm pool, geen fontpakket per app en geen PDF-service om te patchen.
De kostenvergelijking is dus niet “999 USD vs 5 USD” — de licentie is de kleine regel. De echte vergelijking is:
QuestPDF total = license (one-time) + your hosting + your engineer-time + on-call
gPdf total = page bill (infrastructure, fonts, scaling, and edge included)Met de publieke prijs per pagina kost gPdf-meerprijs 0,05 USD per 1.000 pagina’s (50 USD per 1 miljoen, 500 USD per 10 miljoen). Een eenmalige Enterprise-licentie van 2.999 USD bereikt break-even tegenover die rekening pas rond 60 miljoen pagina’s — en dat cijfer negeert QuestPDF’s hosting en engineeringmaanden, die het echte omslagpunt verder richting gPdf duwen tenzij uw renderinfrastructuur al goedkoop draait. Vuistregel: als u een renderservice moet bouwen en bemensen alleen om de bibliotheek te gebruiken, wint gPdf meestal op totale kosten ruim voordat de paginafactuur de licentie inhaalt; als die infrastructuur al bestaat en bijna gratis is, wint de eeuwigdurende licentie op schaal.
Ontwikkelwerkwijze: Fluent C# tegenover sjablonen
QuestPDF’s fluent API past goed wanneer ontwikkelaars de documentvorm bezitten. Sterke typing, method chains, herbruikbare C#-componenten, IDE-refactors en de Companion App zijn logisch wanneer de PDF onderdeel is van de applicatiecodebase.
gPdf past bij een andere werkwijze. Ontwikkelaars kunnen nog steeds direct JSON schrijven, maar productiesystemen bewegen meestal richting sjablonen. Een ontwerper, operator of engineer past de lay-out aan in gPdf Studio. De goedgekeurde lay-out wordt een sjabloon, en de backend blijft renderen met template_id + data.
Dat verschil telt wanneer het document vaak verandert. Als een verzendlabel, factuur, pakbon of overzichtslay-out wijzigt, kan gPdf de runtime stabiel houden terwijl alleen het sjabloon beweegt. Bij QuestPDF is de lay-out C#-code, dus de normale route is codewijziging, test, build, uitrol en rollbackplan.
Geen werkwijze is universeel beter: QuestPDF optimaliseert voor C#-ontwikkelaars die het document als code willen; gPdf voor operationele sjablonen die over systemen worden gedeeld.
Standaardeisen: beide producten zijn serieus
Dit is geen vergelijking waarin gPdf wint door te zeggen dat de concurrent geen standaardfeatures heeft. De huidige publieke materialen van QuestPDF tonen sterke standaardenondersteuning, waaronder PDF/A, PDF/UA-1 en EN 16931 e-facturering via een ZUGFeRD 2.1 / Factur-X-voorbeeld op basis van de UN/CEFACT Cross Industry Invoice (CII)-standaard. Dat voorbeeld zet PdfA = true, embedt het factur-x.xml-bestand met AddAttachment(), breidt het document uit met XMP-metadata en valideert het resultaat met veraPDF (voor PDF/A-3b) en Mustang Project (voor ZUGFeRD). Het is een volledig, eerlijk recept — en uw werkwijze bezit elke stap ervan.
gPdf verpakt dezelfde standaarden als API-contract. JSON Render biedt zes PDF/A-profielen (1b, 2b, 3b, 4, 2u, 3u) plus PDF/UA-1 via settings.profile, Template Render gebruikt hetzelfde documentmodel, en E-Invoice Render biedt een dedicated POST /api/v1/e-invoice/render API-route die Factur-X / ZUGFeRD PDF/A-3b-pakketten produceert met embedded EN 16931 CII XML. Het verschil met het QuestPDF-recept is wat de service voor u doet: gPdf draait PDF/A-3b- en e-factuurvalidatie server-side, ondersteunt synchrone inline levering of levering via opgehaald object, en biedt EU- of wereldwijde dataresidentie als requestinstelling in plaats van stappen die u zelf samenstelt en beheert. QuestPDF past wanneer die validatie in uw eigen .NET-werkwijze moet leven; gPdf wanneer het een gehost contract moet zijn dat veel systemen delen.
Fonts en barcodes: de echte vergelijking is integratie-inspanning
QuestPDF heeft een capabel fontmodel. Het levert standaard Lato 2.015, laadt automatisch systeemfonts en fonts uit de deploymentdirectory, laat u custom fonts via FontManager registreren en ondersteunt fallbackketens. Dat geeft ontwikkelaars controle. Maar dezelfde documentatie is eerlijk over de valkuil: “in most cloud deployments, few or no fonts are available, which may lead to unexpected results,” en adviseert omgevingsfonts uit te zetten en expliciet te registreren wat u nodig hebt. Met andere woorden: op een container of serverless target is de fontomgeving uw werk om te plannen, leveren en testen — en een ontbrekende glyph wordt een placeholder-teken of, als u CheckIfAllTextGlyphsAreAvailable inschakelt, een exception.
gPdf maakt fonts onderdeel van de servicegrens. De renderengine bundelt een multi-script set — Latijn, Grieks, Cyrillisch, Arabisch, Hebreeuws, Bengaals, Tamil, Thai, Vietnamees, monospace en CJK met per-script terugval naar Noto KR / JP / SC. Stille fontkeuzes worden opgelost via impliciete autoselectie, expliciete keuzes via prefer of strict. Aanroepers hoeven geen CJK-font te verzenden, geen Noto-assets in een .NET-app te registreren en geen fontterugval per implementatiedoel af te stemmen. Ze sturen data; de renderengine bezit de fontomgeving, hetzelfde in elke regio.
De barcodevergelijking heeft dezelfde vorm. QuestPDF’s barcode docs tonen een solide aanpak met ZXing.Net gerenderd als vector-SVG, en zeggen expliciet dat ZXing.Net niet in het QuestPDF package zit — u installeert het via NuGet en sluit het aan:
// 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.Met gPdf is barcodegeneratie een volwaardig schema-element. Het request declareert format, content, fysieke maat en een optionele mensleesbare regel — en GS1-formaten zijn native, dus applicatie-identifiers (AI) gaan direct 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" }
}Voor één .NET-app kan ZXing.Net installeren en output testen eenvoudig zijn. Voor veel services en sjablonen — zeker logistieke en retailworkloads die GS1-128, SSCC, GTIN, GS1 DataMatrix of GS1 QR met een mensleesbare interpretatieregel nodig hebben — is barcodegedrag in de document-API eenvoudiger te onderhouden dan dezelfde ZXing-bedrading in elke service opnieuw doen.
Waar QuestPDF duidelijk wint
Naast offline draaien, documentdata binnen uw perimeter houden en situaties waarin de PDF-code zelf onderdeel van het product is — een team dat het renderpad moet inspecteren, uitbreiden of bezitten — heeft QuestPDF twee capability-gebieden die duidelijk buiten gPdf’s scope vallen:
- Operaties op bestaande PDF’s. QuestPDF kan bestaande bestanden laden en samenvoegen, pagina’s selecteren / herschikken / omkeren / filteren, overlays toepassen, bijlagen toevoegen, XMP-metadata zetten, web delivery lineariseren en zowel versleutelen als ontsleutelen met 40/128/256-bit security. gPdf kan wachtwoordbeveiliging en permissies toepassen op PDF’s die het genereert, maar opent, merged of ontsleutelt geen bestanden die het niet heeft gemaakt.
- Grafieken, kaarten en maatwerkgrafiek. QuestPDF integreert grafiekbibliotheken (ScottPlot, LiveCharts, Microcharts), embedt Mapbox-kaarten en biedt een SkiaSharp-canvas voor vrije 2D-tekening. gPdf kan vectorillustraties tekenen met het
path-element (SVG path data) of een upstream geproduceerde SVG / PNG-grafiek embedden, maar heeft geen ingebouwde grafiekengine, kaarten of canvas — als datagedreven grafieken centraal staan, hoort die tooling bij QuestPDF.
Waar gPdf duidelijk wint
gPdf wint wanneer een organisatie niet wil dat elk productteam zijn eigen PDF-service bezit — stacks met meerdere talen, wereldwijde werkwijzen en ERP / OMS / WMS / e-commerce / fintech / ticketingsystemen die documenten renderen uit gestructureerde data, met sjablonen die onafhankelijk van code wijzigen. In zulke omgevingen begint een lokale bibliotheek vaak goedkoop en wordt daarna een vloot: één service per taal, één uitrolpad per regio, één fontplan per container, één set barcoderegressies per team. gPdf verandert die vloot in één HTTP-contract.
Serverless maakt de grens het duidelijkst. Op AWS Lambda, Cloud Run of Azure Functions draait QuestPDF nog steeds binnen de applicatie — uw team verpakt de .NET-runtime, fonts, native dependencies en genoeg CPU / memory voor piek-PDF-werk, en bezit de cold starts. gPdf is al de renderservice: de functie stuurt een klein template_id + data-request naar de edge en krijgt PDF-bytes terug, zonder renderengine om op te warmen of worker per regio om te schalen.
Migratievorm
De migratie van QuestPDF naar gPdf is geen regel-voor-regel herschrijving. Het is een grenswijziging: de C#-code die de PDF bouwt wordt een JSON-documentrequest of een gepubliceerd sjabloon.
Voor / na — de C# document-build call wordt één HTTP POST (klik om uit te klappen)
- // 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();Zodra die grens verschuift, kunnen lay-outwijzigingen sjabloonrevisies worden in plaats van applicatie-uitrollen. De applicatie behoudt businessdata en procesbeslissingen; gPdf bezit rendering.
Prijs- en bronnotitie
Informatie over QuestPDF op deze pagina is op 2026-06-02 gecontroleerd tegen officiële QuestPDF-bronnen: License and Pricing, License configuration, Features Overview, Companion App features, Barcodes, Font management en ZUGFeRD example. Prijzen en featurepagina’s kunnen wijzigen; inkoopteams moeten de leverancierspagina opnieuw controleren voordat ze een aankoopbesluit nemen. QuestPDF en gerelateerde merken behoren toe aan hun respectieve eigenaren, en deze vergelijking wordt niet door hen onderschreven.
Gerelateerde PDF-generatiescenario’s
Teams die QuestPDF en gPdf vergelijken, bepalen meestal of PDF lokaal C#-code moet blijven of een gedeelde service voor meerdere systemen mag worden. Voor de API-route zijn JSON-naar-PDF-API, factuur-PDF-API, verzendlabel-API, PDF/A API, Factur-X API en GS1-barcode-API de nuttigste vervolgstappen.
FAQ
Vervangt gPdf QuestPDF?
Nee. gPdf vervangt de noodzaak om een PDF-generatieservice te beheren voor gestructureerde bedrijfsdocumenten. QuestPDF blijft een sterke lokale C#-bibliotheek wanneer de PDF binnen de applicatie moet worden gegenereerd.
Is QuestPDF gratis?
De publieke licentiepagina van QuestPDF zegt dat de Community-tier gratis is onder MIT-voorwaarden voor in aanmerking komende personen, open-sourceprojecten, non-profits en bedrijven onder 1 miljoen USD jaarlijkse bruto-omzet. Bedrijven boven die grens hebben een eeuwigdurende commerciële licentie nodig: Professional voor 999 USD plus lokale belasting tot 10 ontwikkelaars, of Enterprise voor 2.999 USD plus lokale belasting organisatiebreed, elk met één jaar updates.
Kan gPdf grafieken of kaarten genereren zoals QuestPDF?
Niet als ingebouwde engine. QuestPDF integreert grafiekbibliotheken (ScottPlot, LiveCharts, Microcharts), Mapbox-kaarten en een SkiaSharp-canvas die in het document renderen. gPdf kan nog steeds vectorgrafieken tekenen met het path-element (dat SVG path data accepteert) en vormen, of een SVG / PNG geproduceerd door een willekeurige grafiekbibliotheek embedden als image. Het verschil is dat QuestPDF de grafiek in-process berekent en rendert, terwijl u bij gPdf de grafische output produceert en gPdf die plaatst. Als datagedreven grafieken of kaarten centraal staan in het document, past QuestPDF beter.
Welk product is goedkoper?
Dat hangt af van de grens. QuestPDF kan goedkoper zijn voor .NET-teams die in aanmerking komen voor Community-voorwaarden of die de renderinfrastructuur al beheren. gPdf kan goedkoper zijn wanneer het alternatief is om een PDF-service over producten of regio’s heen te bouwen, hosten en onderhouden.
Slaat gPdf mijn documentdata op of logt het die?
Nee. De JSON die u verzendt en de PDF die gPdf terugstuurt worden niet opgeslagen. Elke request rendert binnen één Cloudflare Workers V8-isolate, alleen in memory tijdens de render — meestal ongeveer 4 ms — en wordt vrijgegeven zodra de response stream klaar is; gPdf bewaart, logt, samplet en traint niet op DocumentRequest-inhoud. Operationele logs bewaren alleen HTTP-status en duur voor 30 dagen en bevatten geen requestbody’s. Zie de security policy, privacy policy en DPA. Voor workloads die helemaal geen data mogen verzenden houdt on-prem / private deployment alles binnen uw vertrouwensgrens.
Kan QuestPDF zonder internettoegang draaien?
Ja. De license configuration page van QuestPDF zegt dat er geen licentiesleutel of activatieserver is en dat computations lokaal worden uitgevoerd. Dat is een van de duidelijkste redenen om QuestPDF te kiezen.
Kan gPdf willekeurige C# QuestPDF layouts renderen?
Nee. gPdf voert geen C#-lay-outcode uit. Een migratie betekent dat de documentvorm wordt omgezet naar een gPdf JSON-request of een opgeslagen gPdf sjabloon.