Skip to content
Belgium live · France mandatory since 1 Sept 2026 — read the guide

Peppol infrastructure for SaaS platforms

Regulation moves. Your code shouldn't have to.One integration puts supported customers on Peppol — and keeps them compliant as each mandate lands.

Your customers invoice through one TypeScript SDK and one master API key. We absorb spec changes, country quirks and new mandates — so you never ship a migration to stay compliant.

$npx @getpeppr/cli validate invoice.json$npm install @getpeppr/sdk

Try with npx first — no signup, no API key. Or check a receiver in the free Peppol lookup. Install the SDK when you're ready to send.

SDK v6.1.0 · CLI v0.14.1 · latest on npm

send-invoice.ts
import { Peppol } from "@getpeppr/sdk";

const peppol = new Peppol({ apiKey: "sk_sandbox_master_..." });

const invoice = await peppol.invoices.send({
  sender: { externalSubTenantId: "customer_8412" },
  number: "INV-2026-001",
  to: {
    name: "SPF Economie (test receiver)",
    peppolId: "9925:BE0314595348",
    street: "Rue du Progrès 50",
    city: "Brussels",
    postalCode: "1210",
    country: "BE",
  },
  lines: [
    { description: "Consultation", quantity: 1,
      unitPrice: 90, vatRate: 0, vatCategory: "O",
      taxExemptReason: "Integration test" },
  ],
});

console.log(invoice.status); // "submitted"

Coverage today

Invoice from nine countries today

Peppol is one network, but every country decides how a company proves who it is. Where we can check that automatically, you sign up and send. Where we can't, we do it with you.

Self-serve · nine countries
  • France
  • Belgium
  • Ireland
  • United Kingdom
  • Netherlands
  • Denmark
  • Germany
  • Sweden
  • Norway

Sign up and send on your own. We check your declared Peppol identifier automatically through the relevant verification source. No call with us and no manual approval on our side — you set yourself up from the console.

Assisted · no countries

    We complete the checks with you and read your first invoice before it goes out.

    Legal mandates

    • Belgium

      Live

      B2B mandate since 1 Jan 2026

      Structured invoices via Peppol BIS for Belgian VAT-taxable B2B.

    • Germany

      Receive live

      since 1 Jan 2025

      Issuing obligations phase in after transitional periods.

    • France

      Receive mandate live

      since 1 Sept 2026

      All receive since 1 Sept 2026; large and mid-sized businesses issue since then, SMEs follow on 1 Sept 2027.

    Regulatory coverage

    Mandate-ready by design

    getpeppr is built on Storecove, a certified Peppol Access Point across the EU. BIS 3.0 revisions, country CIUS layers and network changes ship through that integration — your JSON contract stays exactly the same.

    Certified Access Point backbone

    Storecove is a certified Peppol Access Point connected to the EU Peppol network. BIS 3.0 updates, format revisions, and new country onboardings flow through that integration before reaching your code.

    Country layer, shipped per mandate

    When a new EU mandate lands, getpeppr ships the country-specific layer — identifier schemes, validation rules, CIUS extensions. Your JSON contract stays exactly the same.

    Roadmap aligned with EU regulation

    BIS 3.0 today. Country CIUS as mandates land. ViDA Digital Reporting Requirements for cross-border B2B by 1 July 2030 — same SDK, same contract, same JSON.

    Get a sandbox API key

    Not sure if a company can receive Peppol invoices? Look up any Peppol participant — free, no signup.

    Stop wrestling with XML

    The typical Peppol integration takes 3-5 weeks of reading documentation. Ours takes minutes.

    Before — Raw Peppol
    01

    Read 47-page "quick start" guide

    02

    Understand UBL 2.1 XML schema (150+ elements)

    03

    Learn AS4 protocol for message delivery

    04

    Handle BIS 3.0 validation rules that contradict each other

    05

    Build 150+ lines of XML by hand per invoice

    06

    Contact sales for sandbox access

    3-5 weeks before first invoice

    After — getpeppr SDK
    01

    npm install @getpeppr/sdk

    02

    Write JSON — we generate compliant UBL XML

    03

    Full TypeScript types with autocomplete

    04

    Actionable validation errors with fix suggestions

    05

    Instant self-service sandbox with API keys

    06

    Done. Ship it.

    Minutes to first invoice

    Built for platforms

    One platform account. N legal entities underneath it.

    Your customers each keep their own Peppol identity. Your team keeps one integration. getpeppr models that directly: provision a customer, capture authorisation, send on their behalf, and listen for lifecycle webhooks.

    No XML in your product, no access-point operations in your backlog, and no per-customer onboarding loop rebuilt from scratch.

    Read the Peppol API integration guide

    Your SaaS platform

    One master API key

    Customer A

    Own Peppol identity

    Customer B

    Own authorisation

    Customer C

    Own lifecycle status

    getpeppr

    Verification, UBL/BIS 3.0, Peppol delivery, webhooks

    Try before you buy

    Try Peppol locally. No signup, no API key.

    Validate, look up receivers, and convert UBL invoices from your terminal. Sign up only when you're ready to send through the Peppol network.

    terminal
    $npx @getpeppr/cli validate invoice.json
    Need to check a receiver first?npx @getpeppr/cli lookup 0208:0685660237Use the browser lookup →
    validate · BIS 3.0 offline
    init · scaffold a starter
    lookup · receiver directory

    Read the CLI docs →

    15,000+ tests passing
    TypeScript Native
    Minutes to first invoice
    Built on Peppol BIS 3.0

    Code that speaks for itself

    Every operation is a single, intuitive method call. Full TypeScript autocomplete. No XML, no SOAP, no pain.

    send.ts
    import { Peppol } from "@getpeppr/sdk";
    
    const peppol = new Peppol({ apiKey: "sk_sandbox_..." });
    const identity = await peppol.identity.get();
    if (identity.sandboxFirstSend?.status !== "ready") throw new Error(identity.sandboxFirstSend?.message);
    
    const result = await peppol.invoices.send({
      number: "INV-2026-042",
      // Sandbox delivers only to test recipients — in production,
      // use your customer's Peppol ID.
      to: {
        name: "SPF Economie (test receiver)",
        peppolId: "9925:BE0314595348",
        street: "Rue du Progrès 50",
        city: "Brussels",
        postalCode: "1210",
        country: "BE",
      },
      lines: [
        { description: "Consulting Q1", quantity: 40, unitPrice: 125, ...identity.sandboxFirstSend.line },
        { description: "Travel expenses", quantity: 1, unitPrice: 350, ...identity.sandboxFirstSend.line },
      ],
      paymentTerms: "Net 30 days",
      paymentIban: "BE68539007547034",
    });
    
    console.log(`Sent! ID: ${result.id}`);

    Everything you need to ship Peppol invoices

    Built by developers who spent weeks reading Peppol docs so you don't have to.

    Built country by country

    Self-serve in France, Belgium, Ireland, the United Kingdom, the Netherlands, Denmark, Germany, Sweden and Norway, and we onboard you personally in no more countries. One API — the country-specific rules are ours to carry, not yours.

    Built-in Validation

    Pre-send validation catches errors before they hit the network. Human-readable messages with fix suggestions, not cryptic Peppol rule IDs.

    TypeScript Native

    Full type safety from invoice creation to webhook handling. Autocomplete every field. Catch errors at compile time, not runtime.

    BIS 3.0 Tooling

    Peppol BIS 3.0 tooling out of the box. Generate invoices and credit notes, include allowances and attachments, and track Peppol delivery.

    Real-time Webhooks

    Get notified when invoices are sent, accepted, or refused — pushed as each status lands, retried if your endpoint is down. No polling. Event-driven architecture like Stripe.

    Zero XML

    Send JSON, we generate compliant UBL XML. Your developers will never see an angle bracket. That's a promise.

    Peppol API comparison

    Five providers compared on tenant model, tooling, pricing, onboarding, and market focus. The source-checked guide explains where each one fits.

    getpepprYou are here

    SDKs:
    TypeScript + CLI
    Pricing:
    Business from EUR 49/mo + usage; Platform: one plan at EUR 99/mo + usage, 50 Legal Entities included, no per-customer minimum
    Countries:
    Belgium + France + Ireland + UK + Netherlands + Denmark + Germany + Sweden + Norway self-serve · French regulated CTC not yet open in production · 0 more assisted
    Self-Service:
    Sandbox self-serve; Platform production contract-gated
    Evaluation path:
    Free sandbox + offline CLI

    peppol.sh

    SDKs:
    REST/OpenAPI + code samples; TypeScript SDK published on npm (0.1.0), Python and PHP announced as coming soon
    Pricing:
    Personal EUR 0.20/document; Connect EUR 0.16→0.10 (EUR 250 top-up)
    Countries:
    Developer- and agent-first Peppol
    Self-Service:
    Yes (API-created sandbox)
    Evaluation path:
    Instant API-created sandbox

    e-invoice.be

    SDKs:
    5 languages (TS, Python, PHP, Ruby, Java) + MCP
    Pricing:
    From EUR 0.25/invoice; Enterprise from EUR 0.18
    Countries:
    Belgian certified AP; claims 30+ reachable countries
    Self-Service:
    Yes
    Evaluation path:
    Free sandbox, no sales call

    Storecove

    SDKs:
    RESTful JSON API + OpenAPI/Swagger
    Pricing:
    Quote required
    Countries:
    31-country compliance; Peppol + DBNAlliance
    Self-Service:
    30-day test account by request
    Evaluation path:
    Requested 30-day sandbox

    Basware

    SDKs:
    Network REST API + XML integrations
    Pricing:
    Subscription; contact Basware
    Countries:
    Global network
    Self-Service:
    Support-provisioned test account
    Evaluation path:
    Testing account via Basware Support

    Simple, transparent pricing

    Start free. Send your first invoice in minutes. Scale without surprises.

    Business plans run from a free sandbox to EUR 399/month. The Platform plan lets SaaS products send and receive on behalf of their customer companies, with 50 companies included and no per-customer minimum.

    For companies sending their own Peppol invoices.

    Sandbox

    Free/forever

    Test everything. No credit card required.

    • Unlimited test documents
    • Full SDK access
    • Sandbox environment
    • Validation API
    • Documentation & guides
    Start Building

    No credit card. No time limit.

    Starter

    EUR 49/mo

    For developers and early-stage SaaS.

    100 docs/mo+EUR 0.25/doc
    • 100 documents included (sent + received)
    • Live Peppol delivery
    • Webhooks & events
    • Email support (< 24h)
    • Management dashboard
    • Up to 3 team members
    Most Popular

    Pro

    EUR 149/mo

    For growing businesses.

    800 docs/mo+EUR 0.22/doc
    • 800 documents included (sent + received)
    • Live Peppol delivery
    • Webhooks & events
    • Management dashboard
    • Email support (< 24h)
    • Up to 10 team members

    Business

    EUR 399/mo

    For high-volume document exchange.

    2,000 docs/mo+EUR 0.20/doc
    • 2,000 documents included (sent + received)
    • Live Peppol delivery
    • Webhooks & events
    • Management dashboard
    • Priority email support
    • Up to 25 team members

    All prices in EUR, excluding VAT. Business plans have no setup fees. Platform production access is contract-gated. Usage counts documents both sent and received.

    Frequently asked questions

    Which countries can I send invoices to?

    Any participant on the Peppol network, wherever it is registered — that part does not depend on where you are. What does depend on your country is where you can invoice FROM. We check your declared Peppol identifier automatically through the relevant verification source. You are self-serve in France, Belgium, Ireland, the United Kingdom, the Netherlands, Denmark, Germany, Sweden and Norway today, and we onboard you personally in . The coverage page at getpeppr.dev/countries has the full list.

    Is the sandbox really free?

    Yes. Free forever, unlimited test documents, no credit card required. When you're ready to go live, plans start at EUR 49/month.

    Do I need to understand Peppol or UBL?

    No. Send JSON, we handle the UBL XML generation, BIS 3.0 compliance, and Peppol network delivery. Zero XML knowledge required.

    Is getpeppr production-ready?

    Yes. We run on Storecove's certified Peppol Access Point and production sending is enabled. Our SDK and gateway carry 15,000+ automated tests and are built for Peppol BIS 3.0.

    What is the SaaS Platform plan for?

    It is for SaaS products that send and receive Peppol documents on behalf of many customer companies. Each customer company you register for production counts as one Legal Entity. There is one Platform plan: EUR 99 a month plus EUR 0.25 per document, with 50 Legal Entities included, then EUR 1 per registered Legal Entity per month beyond them. There is no per-customer minimum and no setup fee.

    Can SaaS platforms go live self-serve?

    Sandbox is free, needs no agreement and is self-serve: an organisation admin chooses “A platform for my customers” at signup, or starts the platform sandbox trial later from the console overview, then creates the sandbox master key in the console. Production platform access is contract-gated — we enable it after a signed platform agreement and DPA, so responsibilities, the entity count you are billed on, and data processing terms are clear before live customer sending.

    How is platform usage billed?

    One central bill for the whole platform, never one per customer: the EUR 99 platform fee, EUR 0.25 per document sent or received in production, and EUR 1 per month for each registered customer Legal Entity beyond the 50 included. Accrued usage is charged when it reaches EUR 50, so small volumes never produce noisy micro-charges. There is no per-customer setup fee and no per-customer minimum. Sandbox is free, self-serve and needs no agreement.

    How does getpeppr compare to building with raw Peppol?

    A typical Peppol integration takes 3–5 weeks: reading UBL 2.1 specs, implementing XML generation, handling AS4 protocol, and managing BIS 3.0 validation rules. With getpeppr, you send JSON and we handle everything. Most developers send their first test invoice in minutes, not weeks.

    Roadmap

    v1.1Live

    TypeScript SDK, webhooks, CLI (send + validate + scaffold + lookup), sandbox + production sending

    v1.2Coming next

    France regulated CTC in production for the French mandate (in force since 1 Sept 2026)

    v2.0On the roadmap

    More national rule cartridges

    Ready to ship Peppol invoices?

    Validate locally or create a free sandbox. No credit card, full SDK access.

    $npm install @getpeppr/sdk

    Free sandbox forever. No credit card required. Production access follows the plan you choose.