ZUGFeRD E-Invoice from a SharePoint List: Turn JSON into EN 16931 XML and a PDF/A-3 in Power Automate with PDF4me

PDF4me Create ZUGFeRD Invoice is a Power Automate action that turns invoice data into a hybrid PDF/A-3 e-invoice. Pointed at a SharePoint list, it takes the JSON a Compose action builds from each row, writes the EN 16931 XML itself, draws the readable invoice onto your base PDF, files the result and emails it to the buyer.

Look up ZUGFeRD and you land in one of three places: an explanation of what the format is, a validator that tells you whether a file you already have is correct, or a library in PHP, Java or C# for developers building invoicing software. All three assume the invoice already exists somewhere. The question none of them answers is the one a finance team actually has: the invoice data is sitting in a list, in a spreadsheet, in whatever system records what was sold, and it has to come out the other end as a compliant e-invoice. This flow is that missing middle, in seven actions and without code.

Why-Based Q&A​

What You'll Get​

Input: a row with the invoice number, the dates, the currency, the seller block, the buyer block and one line item. Output: a ZUGFeRD PDF/A-3 invoice in the ZUGFeRD Invoices library, the row updated with its status and a link, and an email to the buyer with the invoice attached.

One row per invoice. Every column in this pane becomes a key in the JSON the flow builds.

One file per invoice number, written by the flow account.

The readable half of the same file, as the buyer sees it.

What You Need​

The Flow at a Glance​

1. When an item is created (SharePoint) watches the list named ZUGFeRD Requests.
2. Compose builds the invoice JSON from the row.
3. Get file content using path reads /ZUGFeRD Templates/BaseInvoice.pdf.
4. Create ZUGFeRD Invoice (PDF4me PDF) converts the JSON to EN 16931 XML and returns the hybrid PDF.
5. Create file (SharePoint) saves it as ZUGFeRD_<invoice number>.pdf.
6. Update item (SharePoint) sets Status to Generated and fills OutputLink.
7. Send an email (V2) (Office 365 Outlook) sends the invoice to the buyer.

Complete flow overview​

Four and a bit seconds end to end, and the e-invoice itself takes about a second. The slowest step is SharePoint writing the file.

Step 1: How do you trigger an e-invoice when a request arrives?​

Flow so far: nothing yet, this is the trigger.

Adding a row is how an invoice gets requested, so that is the signal.

1. Create an Automated cloud flow and pick SharePoint > When an item is created.
2. Configure:
   • Site Address: PDF4me Support - https://ynoox1.sharepoint.com/sites/PDF4meSupport
   • List Name: ZUGFeRD Requests

When an item is created configuration​

Every column on the new row becomes a token the next six actions can use.

Step 2: How do you build the invoice JSON from list columns?​

Flow so far: the SharePoint trigger.

One Compose action describes the whole invoice. This is where your column names meet the names the standard expects, and it is short enough to read on one screen.

1. Add Data Operation > Compose.
2. Paste the object below into Inputs and replace each value with the matching token.

{
  "InvoiceId": "@{triggerBody()?['InvoiceNumber']}",
  "TypeCode": "380",
  "InvoiceType": "RECHNUNG",
  "IssueDate": "@{triggerBody()?['InvoiceDate']}T00:00:00",
  "DeliveryDate": "@{triggerBody()?['InvoiceDate']}T00:00:00",
  "IsTest": false,
  "Seller": {
    "Name": "@{triggerBody()?['SellerName']}",
    "VatId": "@{triggerBody()?['SellerVATID']}",
    "Address": {
      "Street": "@{triggerBody()?['SellerStreet']}",
      "PostalCode": "@{triggerBody()?['SellerPostalCode']}",
      "City": "@{triggerBody()?['SellerCity']}",
      "Country": "@{triggerBody()?['SellerCountry']}"
    }
  },
  "Buyer": {
    "Name": "@{triggerBody()?['BuyerName']}",
    "Address": {
      "Street": "@{triggerBody()?['BuyerStreet']}",
      "PostalCode": "@{triggerBody()?['BuyerPostalCode']}",
      "City": "@{triggerBody()?['BuyerCity']}",
      "Country": "@{triggerBody()?['BuyerCountry']}"
    }
  },
  "LineItems": [
    {
      "ProductName": "@{triggerBody()?['ItemDescription']}",
      "Quantity": @{triggerBody()?['Quantity']},
      "UnitCode": "C62",
      "UnitPrice": @{triggerBody()?['UnitPrice']},
      "LineTotal": @{float(...)}
    }
  ],
  "Totals": {
    "Currency": "@{triggerBody()?['Currency']?['Value']}",
    "LineTotal": @{float(...)},
    "TaxBasisTotal": @{float(...)},
    "TaxPercent": @{triggerBody()?['VATRate']},
    "TaxTotal": @{float(...)},
    "GrandTotal": @{float(...)},
    "ChargeTotal": 0,
    "AllowanceTotal": 0
  },
  "Payment": {
    "Currency": "@{triggerBody()?['Currency']?['Value']}",
    "PaymentReference": "@{triggerBody()?['InvoiceNumber']}",
    "DueDate": "@{triggerBody()?['DueDate']}T00:00:00"
  }
}

Compose configuration​

Text values are tokens in quotes. Money and quantities are bare numbers, which is why they go through float.

Where each part of the invoice comes from​

Step 3: Where does the base PDF come from?​

Flow so far: the trigger plus Compose.

ZUGFeRD files have a readable page, and this is where it starts.

1. Add SharePoint > Get file content using path.
2. Configure:
   • Site Address: PDF4me Support - https://ynoox1.sharepoint.com/sites/PDF4meSupport
   • File Path: /ZUGFeRD Templates/BaseInvoice.pdf
   • Infer content type (advanced): Yes

Get file content using path configuration​

Keep your letterhead in this file. It is read fresh on every run, so changing it changes the next invoice.

Step 4: How do you turn the JSON into a ZUGFeRD PDF/A-3?​

Flow so far: the trigger, Compose and Get file content using path.

This is the action that produces the e-invoice. It reads the JSON, writes the EN 16931 XML itself, and hands back one file with both halves in it.

1. Add Create ZUGFeRD Invoice from the PDF4me PDF connection.
2. Configure:
   • ZUGFeRD version and Input Format: 2.0-JSON
   • Output Mode: XmlWithPdf
   • Invoice JSON Data: the expression base64(outputs('Compose'))
   • Conformance Level: EN16931
   • Render Invoice on PDF: Yes
   • File Content: a base64() expression over the content from Get file content using path
   • File Name: BaseInvoice.pdf

Create ZUGFeRD Invoice configuration​

The input format drives which data field appears. Pick 2.0-JSON and the action asks for Invoice JSON Data, not Invoice XML Data.

What each setting decides​

Step 5: Where does the invoice get filed?​

Flow so far: everything through Create ZUGFeRD Invoice.

The invoice number names the file, which keeps the library searchable.

1. Add SharePoint > Create file.
2. Configure:
   • Site Address: PDF4me Support - https://ynoox1.sharepoint.com/sites/PDF4meSupport
   • Folder Path: /ZUGFeRD Invoices
   • File Name: ZUGFeRD_ followed by the InvoiceNumber token and .pdf
   • File Content: the Body token from Create ZUGFeRD Invoice

Create file configuration​

For RE-2026-0007 this writes ZUGFeRD_RE-2026-0007.pdf.

Step 6: How do you record the result on the request?​

Flow so far: everything through Create file.

The row that asked for the invoice should also say what happened to it.

1. Add SharePoint > Update item.
2. Configure:
   • Site Address: PDF4me Support - https://ynoox1.sharepoint.com/sites/PDF4meSupport
   • List Name: ZUGFeRD Requests
   • Id: the ID token from the trigger
   • Title: the Title token from the trigger
   • Status Value (advanced): Generated
   • OutputLink (advanced): the library URL followed by ZUGFeRD_, the InvoiceNumber token and .pdf

Update item configuration​

The link is assembled from the library URL and the same name pattern Create file used, with the space in the library name already encoded as %20.

Step 7: How do you send the invoice to the buyer?​

Flow so far: everything through Update item.

An e-invoice that stays in a library has not been issued, so the last action delivers it.

1. Add Office 365 Outlook > Send an email (V2).
2. Configure:
   • To: the Email token from the trigger
   • Subject: Your ZUGFeRD e-invoice followed by the InvoiceNumber token
   • Body: a line naming the buyer and the invoice, and saying the file is a PDF/A-3 with embedded EN 16931 XML
3. Open Advanced parameters and add the attachment:
   • Attachments Name - 1: ZUGFeRD_ plus the InvoiceNumber token plus .pdf
   • Attachments Content - 1: the File Content token from Create ZUGFeRD Invoice
   • Importance: Normal

Send an email (V2) configuration​

The attachment takes its bytes from the action that produced them, so SharePoint is never read back.

Run the Flow and Verify​

1. Save the flow.
2. Add a row to ZUGFeRD Requests with a buyer, one line item, both dates and an address you can check.
3. Open the run history. All seven actions should be green, and the whole run should take a few seconds.
4. Open the ZUGFeRD Invoices library and check the file is there under the invoice number.
5. Go back to the row: Status should read Generated and OutputLink should open the invoice.
6. Open the attachment from the email and check both halves: the page should show the right amounts, and the file should carry the XML inside it.

The captured run took about four seconds in total, with the e-invoice itself produced in one of them. The result, ZUGFeRD_RE-2026-0007.pdf, is about 331 KB and renders as a German invoice: seller Muster GmbH in Berlin with VAT ID DE123456789, customer Test Kunde AG in Muenchen, document type 380, one line of Consulting at 19 percent VAT, net 1.005,00 EUR, VAT 190,95 EUR and a total of 1.195,95 EUR.

Common Variations You Can Add Without Rebuilding​

How this compares to the other ways of producing a ZUGFeRD invoice​

Each row describes the alternative. The last row is this flow.

Common questions​

What is a ZUGFeRD invoice?​

A ZUGFeRD invoice is one file that works two ways. It is a normal PDF a person can open and read, and inside it sits an XML attachment holding the same invoice as structured data. The buyer's accounting system reads the XML and books the invoice without anyone typing it in, while the person in accounts payable still sees a page.

The format comes from FeRD, the German forum for electronic invoicing, and its French counterpart is Factur-X, which is the same idea under another name.

What is the ZUGFeRD format?​

Technically it is a PDF/A-3 container with an embedded XML file in the Cross Industry Invoice syntax, and a profile that says how complete the data is. The profile used here is EN16931, which maps to the European semantic standard for e-invoicing: the set of fields that EN 16931 defines as the core of an invoice.

The practical consequence for an automation is that the output is judged on the XML, not on the page. Supply the data the profile asks for and the file passes; make the page prettier and nothing changes.

How to create a ZUGFeRD invoice?​

You need three things: the invoice data in a structured form, a page for the human half, and something that writes the XML into the PDF as a PDF/A-3 attachment.

In this flow the data is a SharePoint row turned into JSON, the page is BaseInvoice.pdf, and Create ZUGFeRD Invoice does the third part with Output Mode XmlWithPdf. If your data already exists as Cross Industry Invoice XML or as a CSV row, switch the input format and feed that instead. The rest of the flow does not change.

What is the difference between ZUGFeRD and XRechnung?​

Both satisfy the same European standard, and the difference is the packaging. ZUGFeRD is hybrid: a readable PDF with the XML inside it, which suits invoices sent to customers who may open them by hand. XRechnung is XML only, and it is the format German public-sector buyers ask for.

If you send to businesses, the hybrid file is usually the safer choice, because it is readable by whoever opens it. If you invoice a public authority, check which format that authority requires before you send.

Troubleshooting​

Next Steps​

The same seven-step pattern (a row arrives, an invoice is described as data, a file is produced, filed, recorded and sent) is what every e-invoicing mandate is really asking for, whichever format your buyers end up needing.