50 free credits/month
Create an account, use public blueprints, and start generating documents on the free plan.
JSON-first document generation
Create invoices, contracts, reports and certificates with reusable JSON blueprints and programmable Jay logic. Send structured data to the API and receive finished PDFs through signed async webhooks.
Free plan includes 50 credits every month.
Create an account, use public blueprints, and start generating documents on the free plan.
Generate PDFs without maintaining Puppeteer, Chrome workers or HTML/CSS rendering pipelines.
A Stripe-style single-page invoice renders in about 20ms in benchmark conditions, without a browser runtime.
Start with a public blueprint or create and store your own private ones. A JayCode blueprint is a JSON document definition enhanced with Jay expressions that compute content dynamically while keeping layout, styling and document logic together.
Use ready-made public examples or create private blueprints for your own document workflows.
Your backend sends structured business data while the blueprint handles layout, formatting and document structure.
Use Jay expressions for conditions, loops, formatting, computed values and decimal calculations instead of scattering document logic across application code.
Use a public document blueprint or create your own reusable JSON template.
Add layout, styles and Jay expressions for conditions, loops, formatting and decimal calculations.
Submit structured business data to the render API as a job.
JayCode renders asynchronously and sends a signed webhook with a signed PDF download URL.
Use conditions, loops, nested data, formatting, computed values and decimal calculations inside reusable blueprints.
Handle automatic page breaks, multi-page tables, repeating table headers, document headers and footers, and page numbers.
Reuse custom fonts plus raster and vector graphics across branded documents.
Build business documents with generated codes, links and other structured document elements.
Submit render jobs asynchronously and receive completion details through signed webhooks with signed PDF URLs.
Render-time errors identify the blueprint element that failed and explain why, with diagnostics delivered through the webhook flow.
JayCode is built for software teams generating recurring or logic-heavy business documents from structured data.
Generate invoices, receipts, statements and payout summaries from order, subscription or marketplace data.
Create agreements, employment documents, policy files and other customer-facing records with dynamic content and consistent formatting.
Produce reports, certificates, delivery notes and business forms from operational data through one API.
Start with 50 free credits every month. Paid-plan pricing and included usage are being finalized and will be published here before paid subscriptions are enabled.
50 credits / month
Create and store private blueprints, use available public blueprints, and generate PDFs through the JayCode API.
Pricing to be published
Paid plans will provide higher usage allowances and rate limits. Final prices and plan details will appear here before checkout is enabled.
JayCode also supports a self-hosted compiler option for organizations with stricter deployment and document-processing requirements.
The renderer does the hard part in milliseconds. In benchmark conditions, a Stripe-style single-page invoice rendered in about 20ms, while multi-page documents reached as low as about 5ms of rendering time per page. We also measured the complete async service across 36,000 jobs, from API request to stored PDF and webhook delivery.
Rendering time for the benchmark's Stripe-style single-page invoice.
Observed rendering time per page for multi-page documents, depending on document complexity.
End-to-end completion time across the full async request, storage and webhook pipeline.
Roughly 90% of total completion time in the benchmark deployment was spent outside the renderer, primarily moving and storing the finished file before webhook delivery.
The full async benchmark completed every submitted job. End-to-end latency measured 174ms p50, 227ms p99 and 268ms p99.9.
Sustained throughput through rendering, file storage and webhook delivery with 2 workers on a 4-core AMD EPYC KVM.
The benchmark reflects the complete production-style workflow, not just an isolated renderer test. The current deployment stores completed PDFs in Amazon S3 in Frankfurt before notifying the caller, so file delivery and storage dominate the measured end-to-end time.
The official client is currently Python-based and supports Django, Flask and standalone applications. Follow the lifecycle from configuration and startup to render submission, webhook handling and shutdown.
# Django settings
JAYCODE_CLIENT_DOWNLOAD_DIR = os.environ.get("JAYCODE_CLIENT_DOWNLOAD_DIR", "downloads")
JAYCODE_CLIENT_DOWNLOAD_WORKERS = int(os.environ.get("JAYCODE_CLIENT_DOWNLOAD_WORKERS", "2"))
JAYCODE_CLIENT_REQUEST_TIMEOUT = int(os.environ.get("JAYCODE_CLIENT_REQUEST_TIMEOUT", "30"))
# Flask config
JAYCODE_CLIENT_DOWNLOAD_DIR = os.environ.get("JAYCODE_CLIENT_DOWNLOAD_DIR", "downloads")
JAYCODE_CLIENT_DOWNLOAD_WORKERS = int(os.environ.get("JAYCODE_CLIENT_DOWNLOAD_WORKERS", "2"))
JAYCODE_CLIENT_REQUEST_TIMEOUT = int(os.environ.get("JAYCODE_CLIENT_REQUEST_TIMEOUT", "30"))
# Plain Python
import os
JAYCODE_CLIENT_DOWNLOAD_DIR = os.getenv("JAYCODE_CLIENT_DOWNLOAD_DIR", "downloads")
JAYCODE_CLIENT_DOWNLOAD_WORKERS = int(os.getenv("JAYCODE_CLIENT_DOWNLOAD_WORKERS", "2"))
_client: JayCodeClient | None = None
def get_client() -> JayCodeClient:
global _client
if _client is None:
_client = build_client()
return _client
_client: JayCodeClient | None = None
def get_client() -> JayCodeClient:
global _client
if _client is None:
_client = build_client()
return _client
from jaycode_client import JayCodeClient
client = JayCodeClient.from_env(callbacks=callbacks, delivery=delivery)
client = client or build_client()
class MyAppConfig(AppConfig):
def ready(self) -> None:
from examples.django_integration import get_client
client = get_client()
client.start()
def create_app() -> Flask:
app = Flask(__name__)
with app.app_context():
get_client().start()
return app
client = get_client()
client.start()
def shutdown_all() -> None:
client.stop()
atexit.register(shutdown_all)
import atexit
atexit.register(client.stop)
import atexit
atexit.register(client.stop)
# submit endpoint
client.submit(blueprint="public/stripe-style-invoice", vars=payload)
# webhook endpoint
client.handle_webhook(request.headers, request.body)
@app.post("/render")
def render_pdf() -> dict[str, str]:
return client.submit(blueprint="public/stripe-style-invoice", vars=payload)
@app.post("/webhook")
def webhook() -> dict[str, str]:
return client.handle_webhook(request.headers, request.get_data())
job = client.submit(blueprint="public/stripe-style-invoice", vars=payload)
result = client.handle_webhook(headers, body)
For complete implementations, see the GitHub repository with the available client examples.
Job completion is delivered through signed webhooks, and generated PDFs are retrieved through signed download URLs.
Generated PDFs are stored in Amazon S3 in the Frankfurt region and retained for 7 days. Private download URLs expire after 1 hour. Retention and data handling are described in the Terms of Service.
The JayCode compiler can be deployed in your own environment for workloads that require local document compilation and stricter control over document processing.
No. JayCode renders JSON blueprints with a purpose-built document runtime instead of converting HTML with Chromium or another browser engine.
A blueprint is a reusable JSON document definition enhanced with Jay expressions for dynamic content, conditions, loops, formatting and calculations.
JayCode is asynchronous. Your application submits a render job, then receives completion details through a signed webhook with a signed PDF download URL.
Blueprints support automatic page breaks, repeating table headers, multi-page tables, headers and footers, page numbers, barcodes, QR codes, links, SVG and raster graphics, conditions, loops, nested data, formatting and decimal computations.
Render-time errors are returned through the webhook flow and identify which blueprint element failed and why.
Generated PDFs are stored in Amazon S3 in the Frankfurt region and retained for 7 days. Private download URLs expire after 1 hour; related job data and logs may be retained for up to 3 weeks as described in the Terms of Service.
The official client is currently Python-based, with integration examples for Django, Flask and standalone Python applications.
No. JayCode blueprints are currently authored as text, which is intended for developers and teams that want versionable, programmable document definitions.
Start with a public blueprint, send structured data, and receive the generated PDF through the signed async delivery flow. The free plan includes 50 credits every month.
Explore focused guides for common PDF generation workflows and migration paths.
For teams looking to turn structured JSON data into final PDFs.
For direct invoice generation from API calls and reusable templates.
For teams moving away from browser-based PDF rendering stacks.
For document workflows that should not depend on HTML/CSS rendering.
For API-first PDF generation with jobs, webhooks, and signed URLs.
For branded invoices, certificates, and reports with reusable assets.