Enterprise‑ready Peppol routing

Enterprise‑ready Peppol routing API and observability platform.

  • Route each document by your workflow.
  • Fail over to the next provider.
  • Analyse in-depth telemetry for each provider.
Book a demo
One billing run, one route
Routing schematic. Your integration sends one billing run to one API. Attempt 1 goes to Provider A, which never accepts it. Attempt 2 sends the same document to Provider B, under your workflow. Provider B delivers it, and the log records: carried by Provider B, attempt 2. Provider C is on standby. The route continues into the capabilities below.Your integrationbilling run · POST /documentsone APIProvider CstandbyProvider Anever acceptedProvider Bsame document,under your workflowDeliveredcarried_by Provider B, attempt 212

One routing layer for every invoice you send

Connect your integration once and use these six capabilities with every provider.

  • One Peppol API

    One integration for every provider, idempotent and asynchronous even when the provider is not.

    What the API covers

  • Your own labels

    Add your own labels to each document. They return in every log line and every export.

    Your labels in every export

  • Guardrails

    Enterprise

    Every IBAN on the invoice is checked before it leaves. An invoice that fails the check is held, and you see why.

    On the Enterprise tier

  • Your routing workflow

    Draw it on a canvas. Set conditions on country, entity, document type and load. Then route, hold, schedule, delay, call a webhook or block a receiver.

    See the workflow examples

  • Bring your own keys

    Scoped, short-lived and revocable, and never in the payment path.

    How we hold your keys

  • One log of every attempt

    Every attempt, every provider and every result, for each invoice you send.

    What we measure

Add providers in three steps

Connect the providers you already pay, choose which one sends each document, and send everything through one API. Your ERP code does not change.

  1. Connect your provider keys

    Add the API keys of the providers you already pay. Sending needs no new registration.

    your keys, one per providerscoped, revocable

  2. Build your routing workflow

    Your routing workflow picks the provider for each invoice. It routes by recipient country, provider load or document type. Failover passes the document to the next provider when one never accepts it.

    your workflow, outside the ERPtriggerInvoiceconditionCountryactionRoutechange it without a release

  3. Send through one API

    Your ERP calls one endpoint and gets one result back. When you add or change a provider, your integration stays the same.

    one endpoint for every providerYour ERPone APIone result back

Routing workflows you draw and change

You draw the workflow on a canvas outside the ERP, so a change needs no release.

Invoices from your French entity to French recipients go through Provider A. Everything else goes through Provider B.

Condition
The recipient country is France and the legal entity label is your French entity.
Route
Provider A, otherwise Provider B.
Log
Entity label, country and provider for each document.
entity French entity country France carried_by Provider Aentity other country other carried_by Provider B

You send a burst of invoices. Provider A takes up to the load you allow. Providers B and C take the rest, each up to its own limit.

Condition
Provider A is at the load you allow.
Route
Providers B and C, each up to its own allowed load.
Log
Provider and load for each document.
carried_by Provider A load within the load you allow Acarried_by Provider C load within the load you allow C

Catalogues go through the provider that carries Peppol BIS Catalogue, invoices through another.

Condition
The document type is catalogue.
Route
Provider A for catalogues, Provider B for invoices.
Log
Document type and provider for each document.
type catalogue carried_by Provider Atype invoice carried_by Provider B

Provider A never accepts the document. Failover passes it to Provider B, the next provider in your workflow.

Condition
Provider A never accepted the document.
Route
Provider B, as attempt 2 of the same document.
Log
Both attempts, the provider that carried it and the result.
attempt 1 Provider A, not acceptedattempt 2 Provider B, delivered carried_by Provider B

Detailed measurements and logs for every document

See how each provider handles the invoices you send, per document, country and entity.

  • Every document, end to end

    You see the provider that carried it, every attempt, and when the provider accepted and delivered it.

  • Every provider, side by side

    Acceptance time, delivery time and failure rate per provider, from your own traffic. Keep a provider, send it less, or show the numbers to the auditor.

  • Reporting in your labels

    Every log line and every export carries your own labels, so your close reconciles per entity, not per provider.

Example provider telemetry, last 7 daysbars run Mon to Sun · filter by country, entity, document type
ProviderAccepted inDelivered inNot acceptedVolumeper dayState
Provider A1.2 s38 s0.4%Healthy
Provider B1.4 s41 s0.6%Healthy
Provider C6.8 s3 min2.1%Sloweron Thu, Fri

Last attempts

  1. 09:41:07 attempt 1 Provider A not accepted
  2. 09:41:09 attempt 2 Provider B delivered
  3. 09:42:15 attempt 1 Provider C delivered

Example view. The numbers come from the invoices you send.

One API call for any provider

Each invoice goes to one API that adds routing, your own labels and a log of every attempt.

request you send
POST /documents
Authorization: Bearer
  ‹short-lived token›
Idempotency-Key: ‹your key›

{
  "document": ‹your invoice›,
  "labels": {
    "legal_entity": "‹your entity›",
    "billing_run": "‹your billing run›"
  }
}
response at once
202 Accepted
{
  "id": "‹document id›",
  "state": "queued"
}
webhook later
POST ‹your webhook URL›

{
  "event": "document.result",
  "state": "delivered",
  "carried_by": "Provider B",
  "attempts": [
    { "provider": "Provider A",
      "state": "not accepted" },
    { "provider": "Provider B",
      "state": "delivered" }
  ],
  "labels": ‹the labels you sent›
}

Example only. The API reference has the exact field names.

Your keys and your routes stay yours

  • Note 1Scoped keys. You give us only what the routing layer needs.
  • Note 2Short-lived tokens. You have no static secret to rotate. Revoke a key at any moment.

Idempotent and asynchronous

  • Note 3Idempotent, even when your provider is not. Send the same document twice and we send it once, matched by your idempotency key or by the document identity.
  • Note 4Asynchronous, even when your provider is not. You get a document id at once. The result comes by webhook, or when you ask for it.

Report on every document

  • Note 5Your own labels. Legal entity, cost centre, billing run or ERP document number. They come back in every result and every export.
  • Note 6Named carrier. The webhook names the provider that carried the document and lists every attempt.

Peppol providers you can bring

Bring the key of any provider with an API, or activate a provider in the product: Maventa, Invopop, Storecove, Billit, Dokapi, SUPERPDP, B2BRouter and others, in no order. Bring two providers or ten, and your workflow can route to each one. You choose them and you contract them.

Pricing for the routing layer

Your Peppol access point price stays with your provider.

  • Developer

    Free

    No card required.

    • One provider key
    • 500 documents a month
    • Full telemetry on every document
    • 30-day retention
    • At 500 documents we stop accepting new ones, so you never owe money
    Book a demo

  • Growth

    Recommended

    EUR249a month

    10,000 documents included, then EUR 0.01 each.

    • Everything in Developer, plus:
    • Unlimited provider keys
    • Routing workflows you draw
    • Failover under the resend rule
    • 90-day retention
    • A monthly cap that you set
    • Email support, next business day
    Book a demo

  • Enterprise

    On request

    For a routing layer that passes your security review.

    • Everything in Growth, plus:
    • SSO and SCIM
    • An audit log API
    • Custom retention and guardrails
    • SLA-backed support with a response time
    • Provider SLOs on your own access points
    Book a demo

Prices exclude VAT. Your own provider keys have no markup on any tier. A provider that you activate in the product has a markup, and we show it.

Questions from finance and IT

Where does PeppolRouter sit in the Peppol network?

In front of your access point. Your invoices reach the Peppol network through the access point that you chose and pay.

We are the routing layer in front of it, with your keys and your workflow.

Can I send through more than one Peppol provider?

Yes. You receive with one provider, and you can send with any provider.

Your registration tells senders where to deliver documents to you. How your invoices leave is your choice, so you keep your current provider and add others.

How does failover keep each invoice single?

We resend only when the provider never accepted the document: a refused connection, a TLS or DNS failure, or a 5xx error before the provider acknowledges the document.

After acceptance, we show you the document, the provider and the elapsed time, and you decide.

How much integration work does a second provider add?

A second contract, and the same integration. You keep one integration, one result back to your ERP, and one record of which provider carried each document.

Which part of the path does routing cover?

The path from your systems to the access points you contract. The Peppol address book (SML) sets the recipient's access point for each document type.

What do you promise?

The mechanism: the resend rule, the workflow you build, and a log of every attempt.

For measured access point availability, see Live Peppol status.

Start with your current Peppol API provider

Bring the API key you already have and send your first invoice through PeppolRouter today. Add more providers when you are ready. Your integration stays the same.

Book a demo
Your first document
  1. your provider key
  2. one API
  3. deliveredcarried_by your provider