PDF generation, built for developers.

import Airpdf from "@airpdf/sdk";

const client = new Airpdf(process.env.AIRPDF_API_KEY);

const pdf = await client.render({
  template: "invoice",
  data: {
    customer: { name: "Acme Inc." },
    items: [{ label: "Pro plan", amount: 99 }],
  },
  response: "binary",
});

await fs.writeFile("invoice.pdf", pdf);
// → 412ms · 18 KB · application/pdf

from airpdf import Airpdf
import os

client = Airpdf(os.environ["AIRPDF_API_KEY"])

pdf = client.render(
    template="invoice",
    data={
        "customer": {"name": "Acme Inc."},
        "items": [{"label": "Pro plan", "amount": 99}],
    },
    response="binary",
)

with open("invoice.pdf", "wb") as f:
    f.write(pdf)
# → 412ms · 18 KB · application/pdf

require "airpdf"

client = Airpdf::Client.new(ENV.fetch("AIRPDF_API_KEY"))

pdf = client.render(
  template: "invoice",
  data: {
    customer: { name: "Acme Inc." },
    items: [{ label: "Pro plan", amount: 99 }]
  },
  response: "binary"
)

File.binwrite("invoice.pdf", pdf)
# → 412ms · 18 KB · application/pdf

use Airpdf\Client;

$client = new Client(getenv("AIRPDF_API_KEY"));

$result = $client->render(
    template: "invoice",
    data: [
        "customer" => ["name" => "Acme Inc."],
        "items" => [["label" => "Pro plan", "amount" => 99]],
    ],
);

file_put_contents("invoice.pdf", $result["pdf"]);
// → 412ms · 18 KB · application/pdf

import (
    "context"
    "os"
    airpdf "github.com/zoonect/airpdf-sdk-go"
)

client, _ := airpdf.New(os.Getenv("AIRPDF_API_KEY"))

res, _ := client.Render(context.Background(), airpdf.RenderRequest{
    Template: "invoice",
    Data: map[string]any{
        "customer": map[string]any{"name": "Acme Inc."},
    },
})

os.WriteFile("invoice.pdf", res.PDF, 0644)
// → 412ms · 18 KB · application/pdf

using Airpdf;

using var client = new AirpdfClient(Environment.GetEnvironmentVariable("AIRPDF_API_KEY")!);

var result = await client.RenderAsync(new RenderRequest {
    Template = "invoice",
    Data = new Dictionary<string, object?> {
        ["customer"] = new { name = "Acme Inc." },
    },
});

if (result is { Kind: RenderResultKind.Binary } bin) {
    await File.WriteAllBytesAsync("invoice.pdf", bin.Pdf!);
}

import it.airpdf.AirpdfClient;
import it.airpdf.RenderRequest;
import it.airpdf.RenderResult;

try (var client = new AirpdfClient(System.getenv("AIRPDF_API_KEY"))) {
    var result = client.render(new RenderRequest()
        .setTemplate("invoice")
        .setData(Map.of(
            "customer", Map.of("name", "Acme Inc.")
        )));

    if (result instanceof RenderResult.Binary bin) {
        Files.write(Path.of("invoice.pdf"), bin.pdf());
    }
}

client = Airpdf.new(api_key: System.fetch_env!("AIRPDF_API_KEY"))

{:ok, %{kind: :binary, pdf: pdf}} =
  Airpdf.render(client,
    template: "invoice",
    data: %{customer: %{name: "Acme Inc."}}
  )

File.write!("invoice.pdf", pdf)
# → 412ms · 18 KB · application/pdf

use airpdf_sdk::{Client, RenderRequest, RenderResult};
use std::collections::HashMap;
use serde_json::json;

let client = Client::new(std::env::var("AIRPDF_API_KEY")?)?;

let mut data = HashMap::new();
data.insert("customer".into(), json!({"name": "Acme Inc."}));

let result = client
    .render(RenderRequest::new("invoice").data(data))
    .await?;

if let RenderResult::Binary { pdf, .. } = result {
    std::fs::write("invoice.pdf", pdf)?;
}

import it.airpdf.AirpdfClient
import it.airpdf.RenderRequest
import it.airpdf.RenderResult
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.*

fun main() = runBlocking {
    AirpdfClient(System.getenv("AIRPDF_API_KEY")).use { client ->
        val data = buildJsonObject {
            put("customer", buildJsonObject { put("name", "Acme Inc.") })
        }
        val result = client.render(RenderRequest(template = "invoice", data = data))
        if (result is RenderResult.Binary) {
            java.io.File("invoice.pdf").writeBytes(result.pdf)
        }
    }
}

import Airpdf

let client = AirpdfClient(apiKey: ProcessInfo.processInfo.environment["AIRPDF_API_KEY"]!)

let result = try await client.render(
    RenderRequest(
        template: "invoice",
        data: ["customer": .object(["name": .string("Acme Inc.")])]
    )
)

if case .binary(let pdf, _) = result {
    try pdf.write(to: URL(fileURLWithPath: "invoice.pdf"))
}

import 'dart:io';
import 'package:airpdf/airpdf.dart';

Future<void> main() async {
  final client = AirpdfClient(Platform.environment['AIRPDF_API_KEY']!);

  final result = await client.render(RenderRequest(
    template: 'invoice',
    data: {'customer': {'name': 'Acme Inc.'}},
  ));

  if (result is RenderBinary) {
    File('invoice.pdf').writeAsBytesSync(result.pdf);
  }
}

$ curl -X POST https://airpdf-app.it/api/v1/render \
  -H "Authorization: Bearer $AIRPDF_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "template": "invoice",
    "data": {
      "customer": {"name": "Acme Inc."},
      "items": [{"label": "Pro plan", "amount": 99}]
    },
    "response": "binary"
  }' -o invoice.pdf

→ 200 OK · application/pdf · 18 KB · 412ms