🧾Generate & Send an E-Invoice

Learn how to generate and dispatch invoices through Docs-Dispatcher with complete end-to-end examples in 4 languages (curl, Node.js, PHP, Java).

Overview

This comprehensive recipe walks you through the complete invoice generation and dispatch workflow:

1. Set up Basic Authentication credentials

2. Prepare your invoice data

3. Validate the request (recommended safety check)

4. Send the invoice to your accounting provider

5. Handle the response and track status

By the end of this guide, you'll have working code to automatically generate and send invoices to providers like Qonto, PennyLane, and iPaidThat.

What You'll Learn

• How to structure invoice requests for different providers

• Best practices for validation before sending

• Error handling strategies

• Async vs sync dispatch modes

• Provider-specific features and limitations

• Complete working examples in 4 languages

Prerequisites

Before you begin:

• Docs-Dispatcher account with email and password

• At least one invoicing provider configured (Qonto, PennyLane, iPaidThat, or SuperPDP)

• Template created in Templater (or use API to create one)

• Basic understanding of REST APIs

No provider configured yet? You can still test with the validation endpoint - it checks your request format without calling external APIs or charging credits.

Step 1: Authentication

Dispatcher API uses HTTP Basic Authentication. You'll need your Dispatcher account email and password for all API calls.

Setup Credentials

# Store credentials as environment variables
export EMAIL="[email protected]"
export PASSWORD="your-password"

No token management needed! Unlike JWT-based APIs, Basic Auth doesn't require separate authentication endpoints or token refresh. Your credentials are sent with each request.

Quick links:

• Full authentication guide

• Using Basic Auth with Dispatcher

Step 2: Prepare Invoice Data

Structure your invoice data according to the CompositeRequest model. The request has two main parts:

1. Template - Specifies which template to use and the data to populate it

2. Service fields - Provider name, document type, and invoicing-specific options

Basic Invoice Structure

{
  "providerName": "qonto",
  "documentType": "INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "INV-2026-001",
      "date": "2026-02-13",
      "dueDate": "2026-03-13",
      "customer": {
        "name": "Acme Corp",
        "email": "[email protected]",
        "address": "123 Main St",
        "city": "Paris",
        "postalCode": "75001",
        "country": "FR"
      },
      "items": [
        {
          "description": "Web Development Services",
          "quantity": 10,
          "unitPrice": 150.00,
          "total": 1500.00
        },
        {
          "description": "Logo Design",
          "quantity": 1,
          "unitPrice": 500.00,
          "total": 500.00
        }
      ],
      "subtotal": 2000.00,
      "taxRate": 0.20,
      "taxAmount": 400.00,
      "total": 2400.00
    }
  },
  "invoicing": {
    "dueDate": "2026-03-13",
    "paymentTerms": "Net 30"
  },
  "metadata": {
    "orderId": "ORD-2026-12345",
    "customerId": "CUST-789",
    "source": "web"
  }
}

Required Fields

Field	Type	Description
providerName	string	Provider to use: qonto, pennylane, ipaidthat, superpdp
documentType	string	Document type: INVOICE, E_INVOICE, QUOTE, CREDIT
template.id	number	Template ID from Templater
template.data	object	Template variables (schema depends on template)

Optional Fields

Field	Type	Description
invoicing.dueDate	string	Payment due date (ISO 8601 format)
invoicing.paymentTerms	string	Payment terms description (e.g., "Net 30")
invoicing.customerId	string	Provider's customer ID
metadata	object	Custom tracking data (max 20 key-value pairs)

Template Data Schema

The template.data object schema depends on your template. Common fields include:

• Invoice details: invoiceNumber, date, dueDate

• Customer info: name, email, address, city, postalCode, country

• Line items: Array of {description, quantity, unitPrice, total}

• Totals: subtotal, taxRate, taxAmount, total

• Payment: paymentTerms, bankDetails

• Additional: notes, conditions, custom fields

How do I know my template schema? View your template in Templater UI to see expected fields, or use the validation endpoint to test - it will report missing required fields.

Step 3: Validate Request (Recommended)

Before sending real invoices, validate your request structure. This checks for errors without calling external providers or charging credits.

Why Validate?

• Catch errors early (before external API calls)

• Free and fast (< 100ms response)

• No risk of duplicate invoices

• Test during development

• Verify template data schema

Validation Request

curl -X POST https://api.docs-dispatcher.io/api/invoicing/validate \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "providerName": "qonto",
    "documentType": "INVOICE",
    "template": {
      "id": 123,
      "data": {
        "invoiceNumber": "INV-2026-001",
        "date": "2026-02-13",
        "dueDate": "2026-03-13",
        "customer": {
          "name": "Acme Corp",
          "email": "[email protected]",
          "address": "123 Main St, Paris"
        },
        "items": [
          {
            "description": "Web Development",
            "quantity": 10,
            "unitPrice": 150.00,
            "total": 1500.00
          }
        ],
        "subtotal": 1500.00,
        "taxRate": 0.20,
        "taxAmount": 300.00,
        "total": 1800.00
      }
    }
  }'

Validation Success Response

{
  "valid": true,
  "message": "Request is valid and ready for dispatch",
  "warnings": []
}

Validation Error Response

{
  "valid": false,
  "errors": [
    {
      "field": "template.data.dueDate",
      "message": "Due date must be after invoice date",
      "value": "2026-02-01"
    },
    {
      "field": "template.data.total",
      "message": "Total (1800.00) does not match subtotal (1500.00) + tax (300.00)",
      "expected": 1800.00,
      "actual": 1700.00
    }
  ]
}

Validation passed? You're ready to send the real invoice! Simply change /validate to /invoicing in the endpoint URL.

More on validation:

• Validation guide

• Validate then Send recipe

Step 4: Send Invoice (Real Dispatch)

Once validation passes, send the actual invoice by changing the endpoint from /validate to /invoicing.

Sync Mode (Default)

Synchronous mode waits for the provider to complete the operation and returns the full response immediately.

curl -X POST https://api.docs-dispatcher.io/api/invoicing \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "providerName": "qonto",
    "documentType": "INVOICE",
    "template": {
      "id": 123,
      "data": {
        "invoiceNumber": "INV-2026-001",
        "date": "2026-02-13",
        "dueDate": "2026-03-13",
        "customer": {
          "name": "Acme Corp",
          "email": "[email protected]",
          "address": "123 Main St",
          "city": "Paris",
          "postalCode": "75001",
          "country": "FR"
        },
        "items": [
          {
            "description": "Web Development Services",
            "quantity": 10,
            "unitPrice": 150.00,
            "total": 1500.00
          },
          {
            "description": "Logo Design",
            "quantity": 1,
            "unitPrice": 500.00,
            "total": 500.00
          }
        ],
        "subtotal": 2000.00,
        "taxRate": 0.20,
        "taxAmount": 400.00,
        "total": 2400.00
      }
    },
    "invoicing": {
      "dueDate": "2026-03-13",
      "paymentTerms": "Net 30"
    },
    "metadata": {
      "orderId": "ORD-2026-12345",
      "customerId": "CUST-789"
    }
  }'

Success Response:

{
  "success": true,
  "dispatchId": "disp_inv_abc123def456",
  "providerResponse": {
    "invoiceId": "qonto_inv_789",
    "invoiceNumber": "INV-2026-001",
    "status": "sent",
    "url": "https://qonto.com/invoices/789",
    "createdAt": "2026-02-13T12:30:00Z",
    "dueDate": "2026-03-13T23:59:59Z"
  },
  "generatedDocument": {
    "url": "https://storage.docs-dispatcher.io/invoices/INV-2026-001.pdf",
    "size": 245678,
    "contentType": "application/pdf",
    "expiresAt": "2026-03-13T12:30:00Z"
  },
  "metadata": {
    "orderId": "ORD-2026-12345",
    "customerId": "CUST-789"
  },
  "executionTime": 2.3
}

When to use sync mode:

• User is waiting for result (interactive workflows)

• Quick operations (expected completion < 30 seconds)

• Simple error handling (errors returned immediately)

• Testing and development

Async Mode (Recommended for Production)

Asynchronous mode queues the request immediately and processes it in the background. You receive a webhook notification when complete.

curl -X POST https://api.docs-dispatcher.io/api/invoicing?async=true \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "providerName": "qonto",
    "documentType": "INVOICE",
    "template": {
      "id": 123,
      "data": {
        "invoiceNumber": "INV-2026-001",
        "date": "2026-02-13",
        "customer": {...},
        "items": [...],
        "total": 2400.00
      }
    },
  }'

Immediate Response:

{
  "success": true,
  "dispatchId": "disp_async_ghi789xyz",
  "status": "queued",
  "queuedAt": "2026-02-13T12:30:00Z",
  "estimatedCompletionTime": "2026-02-13T12:32:00Z"
}

{
  "event": "dispatch_completed",
  "dispatchId": "disp_async_ghi789xyz",
  "service": "invoicing",
  "status": "success",
  "timestamp": "2026-02-13T12:31:45Z",
  "data": {
    "providerResponse": {
      "invoiceId": "qonto_inv_789",
      "status": "sent",
      "url": "https://qonto.com/invoices/789"
    },
    "generatedDocument": {
      "url": "https://storage.docs-dispatcher.io/invoices/INV-2026-001.pdf",
      "size": 245678
    }
  },
  "metadata": {
    "orderId": "ORD-2026-12345"
  }
}

When to use async mode:

• Background jobs and batch processing

• Long-running operations (> 30 seconds)

• High volume scenarios

• Non-interactive workflows

• Better scalability and resilience

More on execution modes:

• Sync vs Async guide

• Async Flow recipe

• Webhook events

Step 5: Handle Response

Process the dispatch response and handle errors gracefully.

Success Response Fields

Field	Description
success	true if dispatch succeeded
dispatchId	Unique dispatch identifier (use for tracking)
providerResponse	Provider-specific response (invoiceId, status, url)
generatedDocument	Generated PDF document URL and metadata
metadata	Your custom tracking data (echoed back)
executionTime	Processing time in seconds (sync mode only)

Error Response

{
  "success": false,
  "error": "provider_error",
  "message": "Invoice creation failed: Duplicate invoice number",
  "dispatchId": "disp_failed_abc123",
  "providerError": {
    "code": "DUPLICATE_INVOICE",
    "message": "Invoice INV-2026-001 already exists",
    "details": {
      "existingInvoiceId": "qonto_inv_123",
      "existingInvoiceUrl": "https://qonto.com/invoices/123"
    }
  }
}

Common Error Types

Error Type	Cause	Solution
validation_error	Invalid request format	Check required fields, field types
authentication_error	Invalid/expired JWT	Refresh token, re-authenticate
provider_error	Provider API error	Check provider error details
template_not_found	Template ID doesn't exist	Verify template ID in Templater
configuration_missing	Provider not configured	Configure provider credentials
timeout	Operation took too long	Use async mode instead

HTTP Status Codes

Status	Meaning
200 OK	Success (sync mode) or queued (async mode)
400 Bad Request	Invalid request format
401 Unauthorized	Missing/invalid JWT
404 Not Found	Template or resource not found
422 Unprocessable Entity	Validation failed
500 Internal Server Error	Server error
503 Service Unavailable	Provider temporarily unavailable

Complete Examples

Here are complete, runnable examples in 4 languages showing the full invoice workflow from authentication to dispatch.

curl (Complete Flow)

#!/bin/bash

# Step 1: Authenticate
echo "Step 1: Getting Basic Auth credentials..."
AUTH_RESPONSE=$(curl -s -X POST https://api.docs-dispatcher.io/auth \
  -H "Content-Type: application/json" \
  -d '{
    "email": "[email protected]",
    "password": "your-secure-password"
  }')

JWT_TOKEN=$(echo $AUTH_RESPONSE | jq -r '.token')
echo "JWT Token: ${JWT_TOKEN:0:20}..."

# Step 2: Prepare invoice data
INVOICE_REQUEST='{
  "providerName": "qonto",
  "documentType": "INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "INV-2026-001",
      "date": "2026-02-13",
      "dueDate": "2026-03-13",
      "customer": {
        "name": "Acme Corp",
        "email": "[email protected]",
        "address": "123 Main St",
        "city": "Paris",
        "postalCode": "75001",
        "country": "FR"
      },
      "items": [
        {
          "description": "Web Development Services",
          "quantity": 10,
          "unitPrice": 150.00,
          "total": 1500.00
        },
        {
          "description": "Logo Design",
          "quantity": 1,
          "unitPrice": 500.00,
          "total": 500.00
        }
      ],
      "subtotal": 2000.00,
      "taxRate": 0.20,
      "taxAmount": 400.00,
      "total": 2400.00
    }
  },
  "invoicing": {
    "dueDate": "2026-03-13",
    "paymentTerms": "Net 30"
  },
  "metadata": {
    "orderId": "ORD-2026-12345",
    "customerId": "CUST-789",
    "source": "api"
  }
}'

# Step 3: Validate request
echo "Step 2: Validating invoice request..."
VALIDATION_RESPONSE=$(curl -s -X POST https://api.docs-dispatcher.io/api/invoicing/validate \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d "$INVOICE_REQUEST")

VALID=$(echo $VALIDATION_RESPONSE | jq -r '.valid')
if [ "$VALID" = "true" ]; then
  echo "Validation passed!"
else
  echo "Validation failed:"
  echo $VALIDATION_RESPONSE | jq '.errors'
  exit 1
fi

# Step 4: Send invoice
echo "Step 3: Sending invoice..."
DISPATCH_RESPONSE=$(curl -s -X POST https://api.docs-dispatcher.io/api/invoicing \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d "$INVOICE_REQUEST")

# Step 5: Handle response
SUCCESS=$(echo $DISPATCH_RESPONSE | jq -r '.success')
if [ "$SUCCESS" = "true" ]; then
  echo "Invoice sent successfully!"
  echo "Dispatch ID: $(echo $DISPATCH_RESPONSE | jq -r '.dispatchId')"
  echo "Invoice ID: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.invoiceId')"
  echo "Invoice URL: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.url')"
  echo "Document URL: $(echo $DISPATCH_RESPONSE | jq -r '.generatedDocument.url')"
else
  echo "Invoice dispatch failed:"
  echo $DISPATCH_RESPONSE | jq
  exit 1
fi

Node.js (Complete Flow)

const fetch = require('node-fetch');

// Configuration
const CONFIG = {
  templaterApiUrl: 'https://api.docs-dispatcher.io',
  dispatcherApiUrl: 'https://api.docs-dispatcher.io',
  email: '[email protected]',
  password: 'your-secure-password'
};

// Step 1: Authentication
async function authenticate() {
  console.log('Step 1: Getting Basic Auth credentials...');

  const response = await fetch(`${CONFIG.templaterApiUrl}/auth`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      email: CONFIG.email,
      password: CONFIG.password
    })
  });

  if (!response.ok) {
    throw new Error(`Authentication failed: ${response.statusText}`);
  }

  const data = await response.json();
  console.log(`JWT Token obtained (expires: ${data.expiresAt})`);

  return data.token;
}

// Step 2: Prepare invoice data
function prepareInvoiceData() {
  return {
    providerName: 'qonto',
    documentType: 'INVOICE',
    template: {
      id: 123,
      data: {
        invoiceNumber: 'INV-2026-001',
        date: '2026-02-13',
        dueDate: '2026-03-13',
        customer: {
          name: 'Acme Corp',
          email: '[email protected]',
          address: '123 Main St',
          city: 'Paris',
          postalCode: '75001',
          country: 'FR'
        },
        items: [
          {
            description: 'Web Development Services',
            quantity: 10,
            unitPrice: 150.00,
            total: 1500.00
          },
          {
            description: 'Logo Design',
            quantity: 1,
            unitPrice: 500.00,
            total: 500.00
          }
        ],
        subtotal: 2000.00,
        taxRate: 0.20,
        taxAmount: 400.00,
        total: 2400.00
      }
    },
    invoicing: {
      dueDate: '2026-03-13',
      paymentTerms: 'Net 30'
    },
    metadata: {
      orderId: 'ORD-2026-12345',
      customerId: 'CUST-789',
      source: 'api'
    }
  };
}

// Step 3: Validate request
async function validateInvoice(jwtToken, invoiceData) {
  console.log('Step 2: Validating invoice request...');

  const response = await fetch(
    `${CONFIG.dispatcherApiUrl}/api/invoicing/validate`,
    {
      method: 'POST',
      headers: {
        'Authorization': authHeader,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(invoiceData)
    }
  );

  const validation = await response.json();

  if (!validation.valid) {
    console.error('Validation failed:');
    validation.errors.forEach(err => {
      console.error(`  - ${err.field}: ${err.message}`);
    });
    throw new Error('Validation failed');
  }

  console.log('Validation passed!');

  if (validation.warnings && validation.warnings.length > 0) {
    console.warn('Warnings:');
    validation.warnings.forEach(warn => {
      console.warn(`  - ${warn.field}: ${warn.message}`);
    });
  }

  return validation;
}

// Step 4: Send invoice
async function sendInvoice(jwtToken, invoiceData) {
  console.log('Step 3: Sending invoice...');

  const response = await fetch(
    `${CONFIG.dispatcherApiUrl}/api/invoicing`,
    {
      method: 'POST',
      headers: {
        'Authorization': authHeader,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(invoiceData)
    }
  );

  const result = await response.json();

  if (!result.success) {
    throw new Error(
      `Invoice dispatch failed: ${result.message}\n` +
      `Provider error: ${JSON.stringify(result.providerError)}`
    );
  }

  console.log('Invoice sent successfully!');
  return result;
}

// Step 5: Handle response
function handleResponse(result) {
  console.log('\n=== Invoice Dispatch Result ===');
  console.log(`Dispatch ID: ${result.dispatchId}`);
  console.log(`Invoice ID: ${result.providerResponse.invoiceId}`);
  console.log(`Status: ${result.providerResponse.status}`);
  console.log(`Invoice URL: ${result.providerResponse.url}`);
  console.log(`Document URL: ${result.generatedDocument.url}`);
  console.log(`Document Size: ${result.generatedDocument.size} bytes`);
  console.log(`Execution Time: ${result.executionTime}s`);

  if (result.metadata) {
    console.log('\nMetadata:');
    Object.entries(result.metadata).forEach(([key, value]) => {
      console.log(`  ${key}: ${value}`);
    });
  }
}

// Main execution flow
async function main() {
  try {
    // Step 1: Authenticate
    const email = process.env.DOCS_DISPATCHER_EMAIL;
const password = process.env.DOCS_DISPATCHER_PASSWORD;
const authHeader = createBasicAuthHeader(email, password);
// await authenticate();

    // Step 2: Prepare data
    const invoiceData = prepareInvoiceData();

    // Step 3: Validate
    await validateInvoice(jwtToken, invoiceData);

    // Step 4: Send invoice
    const result = await sendInvoice(jwtToken, invoiceData);

    // Step 5: Handle response
    handleResponse(result);

  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

// Run
main();

PHP (Complete Flow)

<?php
require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;

// Configuration
class Config {
    const TEMPLATER_API_URL = 'https://api.docs-dispatcher.io';
    const DISPATCHER_API_URL = 'https://api.docs-dispatcher.io';
    const EMAIL = '[email protected]';
    const PASSWORD = 'your-secure-password';
}

class InvoiceDispatcher {
    private $client;
    private $jwtToken;

    public function __construct() {
        $this->client = new Client();
    }

    // Step 1: Authentication
    public function authenticate() {
        echo "Step 1: Getting Basic Auth credentials...\n";

        try {
            $response = $this->client->post(Config::TEMPLATER_API_URL . '/auth', [
                'json' => [
                    'email' => Config::EMAIL,
                    'password' => Config::PASSWORD
                ]
            ]);

            $data = json_decode($response->getBody(), true);
            $this->jwtToken = $data['token'];

            echo "JWT Token obtained (expires: {$data['expiresAt']})\n";

            return $this->jwtToken;

        } catch (RequestException $e) {
            throw new Exception("Authentication failed: " . $e->getMessage());
        }
    }

    // Step 2: Prepare invoice data
    public function prepareInvoiceData() {
        return [
            'providerName' => 'qonto',
            'documentType' => 'INVOICE',
            'template' => [
                'id' => 123,
                'data' => [
                    'invoiceNumber' => 'INV-2026-001',
                    'date' => '2026-02-13',
                    'dueDate' => '2026-03-13',
                    'customer' => [
                        'name' => 'Acme Corp',
                        'email' => '[email protected]',
                        'address' => '123 Main St',
                        'city' => 'Paris',
                        'postalCode' => '75001',
                        'country' => 'FR'
                    ],
                    'items' => [
                        [
                            'description' => 'Web Development Services',
                            'quantity' => 10,
                            'unitPrice' => 150.00,
                            'total' => 1500.00
                        ],
                        [
                            'description' => 'Logo Design',
                            'quantity' => 1,
                            'unitPrice' => 500.00,
                            'total' => 500.00
                        ]
                    ],
                    'subtotal' => 2000.00,
                    'taxRate' => 0.20,
                    'taxAmount' => 400.00,
                    'total' => 2400.00
                ]
            ],
            'invoicing' => [
                'dueDate' => '2026-03-13',
                'paymentTerms' => 'Net 30'
            ],
            'metadata' => [
                'orderId' => 'ORD-2026-12345',
                'customerId' => 'CUST-789',
                'source' => 'api'
            ]
        ];
    }

    // Step 3: Validate request
    public function validateInvoice($invoiceData) {
        echo "Step 2: Validating invoice request...\n";

        try {
            $response = $this->client->post(
                Config::DISPATCHER_API_URL . '/api/invoicing/validate',
                [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $this->jwtToken,
                        'Content-Type' => 'application/json'
                    ],
                    'json' => $invoiceData
                ]
            );

            $validation = json_decode($response->getBody(), true);

            if (!$validation['valid']) {
                echo "Validation failed:\n";
                foreach ($validation['errors'] as $error) {
                    echo "  - {$error['field']}: {$error['message']}\n";
                }
                throw new Exception('Validation failed');
            }

            echo "Validation passed!\n";

            if (isset($validation['warnings']) && count($validation['warnings']) > 0) {
                echo "Warnings:\n";
                foreach ($validation['warnings'] as $warning) {
                    echo "  - {$warning['field']}: {$warning['message']}\n";
                }
            }

            return $validation;

        } catch (RequestException $e) {
            throw new Exception("Validation request failed: " . $e->getMessage());
        }
    }

    // Step 4: Send invoice
    public function sendInvoice($invoiceData) {
        echo "Step 3: Sending invoice...\n";

        try {
            $response = $this->client->post(
                Config::DISPATCHER_API_URL . '/api/invoicing',
                [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $this->jwtToken,
                        'Content-Type' => 'application/json'
                    ],
                    'json' => $invoiceData
                ]
            );

            $result = json_decode($response->getBody(), true);

            if (!$result['success']) {
                throw new Exception(
                    "Invoice dispatch failed: {$result['message']}\n" .
                    "Provider error: " . json_encode($result['providerError'])
                );
            }

            echo "Invoice sent successfully!\n";
            return $result;

        } catch (RequestException $e) {
            throw new Exception("Invoice dispatch failed: " . $e->getMessage());
        }
    }

    // Step 5: Handle response
    public function handleResponse($result) {
        echo "\n=== Invoice Dispatch Result ===\n";
        echo "Dispatch ID: {$result['dispatchId']}\n";
        echo "Invoice ID: {$result['providerResponse']['invoiceId']}\n";
        echo "Status: {$result['providerResponse']['status']}\n";
        echo "Invoice URL: {$result['providerResponse']['url']}\n";
        echo "Document URL: {$result['generatedDocument']['url']}\n";
        echo "Document Size: {$result['generatedDocument']['size']} bytes\n";
        echo "Execution Time: {$result['executionTime']}s\n";

        if (isset($result['metadata'])) {
            echo "\nMetadata:\n";
            foreach ($result['metadata'] as $key => $value) {
                echo "  $key: $value\n";
            }
        }
    }

    // Main execution
    public function run() {
        try {
            // Step 1: Authenticate
            $this->authenticate();

            // Step 2: Prepare data
            $invoiceData = $this->prepareInvoiceData();

            // Step 3: Validate
            $this->validateInvoice($invoiceData);

            // Step 4: Send invoice
            $result = $this->sendInvoice($invoiceData);

            // Step 5: Handle response
            $this->handleResponse($result);

        } catch (Exception $e) {
            echo "Error: " . $e->getMessage() . "\n";
            exit(1);
        }
    }
}

// Run
$dispatcher = new InvoiceDispatcher();
$dispatcher->run();

Java (Complete Flow)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;

public class InvoiceDispatcher {

    // Configuration
    private static final String TEMPLATER_API_URL = "https://api.docs-dispatcher.io";
    private static final String DISPATCHER_API_URL = "https://api.docs-dispatcher.io";
    private static final String EMAIL = "[email protected]";
    private static final String PASSWORD = "your-secure-password";

    private final HttpClient client;
    private final Gson gson;
    private String jwtToken;

    public InvoiceDispatcher() {
        this.client = HttpClient.newHttpClient();
        this.gson = new Gson();
    }

    // Step 1: Authentication
    public String authenticate() throws Exception {
        System.out.println("Step 1: Getting Basic Auth credentials...");

        Map<String, String> authData = new HashMap<>();
        authData.put("email", EMAIL);
        authData.put("password", PASSWORD);

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(TEMPLATER_API_URL + "/auth"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(authData)))
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() != 200) {
            throw new Exception("Authentication failed: " + response.body());
        }

        JsonObject data = gson.fromJson(response.body(), JsonObject.class);
        this.jwtToken = data.get("token").getAsString();

        System.out.println("JWT Token obtained (expires: " +
            data.get("expiresAt").getAsString() + ")");

        return this.jwtToken;
    }

    // Step 2: Prepare invoice data
    public Map<String, Object> prepareInvoiceData() {
        Map<String, Object> invoice = new HashMap<>();

        invoice.put("providerName", "qonto");
        invoice.put("documentType", "INVOICE");

        // Template
        Map<String, Object> template = new HashMap<>();
        template.put("id", 123);

        // Template data
        Map<String, Object> templateData = new HashMap<>();
        templateData.put("invoiceNumber", "INV-2026-001");
        templateData.put("date", "2026-02-13");
        templateData.put("dueDate", "2026-03-13");

        // Customer
        Map<String, String> customer = new HashMap<>();
        customer.put("name", "Acme Corp");
        customer.put("email", "[email protected]");
        customer.put("address", "123 Main St");
        customer.put("city", "Paris");
        customer.put("postalCode", "75001");
        customer.put("country", "FR");
        templateData.put("customer", customer);

        // Items
        List<Map<String, Object>> items = new ArrayList<>();

        Map<String, Object> item1 = new HashMap<>();
        item1.put("description", "Web Development Services");
        item1.put("quantity", 10);
        item1.put("unitPrice", 150.00);
        item1.put("total", 1500.00);
        items.add(item1);

        Map<String, Object> item2 = new HashMap<>();
        item2.put("description", "Logo Design");
        item2.put("quantity", 1);
        item2.put("unitPrice", 500.00);
        item2.put("total", 500.00);
        items.add(item2);

        templateData.put("items", items);
        templateData.put("subtotal", 2000.00);
        templateData.put("taxRate", 0.20);
        templateData.put("taxAmount", 400.00);
        templateData.put("total", 2400.00);

        template.put("data", templateData);
        invoice.put("template", template);

        // Invoicing options
        Map<String, String> invoicing = new HashMap<>();
        invoicing.put("dueDate", "2026-03-13");
        invoicing.put("paymentTerms", "Net 30");
        invoice.put("invoicing", invoicing);

        // Metadata
        Map<String, String> metadata = new HashMap<>();
        metadata.put("orderId", "ORD-2026-12345");
        metadata.put("customerId", "CUST-789");
        metadata.put("source", "api");
        invoice.put("metadata", metadata);

        return invoice;
    }

    // Step 3: Validate request
    public JsonObject validateInvoice(Map<String, Object> invoiceData) throws Exception {
        System.out.println("Step 2: Validating invoice request...");

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(DISPATCHER_API_URL + "/api/invoicing/validate"))
            .header("Authorization", "Bearer " + this.jwtToken)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(invoiceData)))
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        JsonObject validation = gson.fromJson(response.body(), JsonObject.class);

        if (!validation.get("valid").getAsBoolean()) {
            System.err.println("Validation failed:");
            validation.getAsJsonArray("errors").forEach(error -> {
                JsonObject err = error.getAsJsonObject();
                System.err.println("  - " + err.get("field").getAsString() +
                    ": " + err.get("message").getAsString());
            });
            throw new Exception("Validation failed");
        }

        System.out.println("Validation passed!");

        if (validation.has("warnings") &&
            validation.getAsJsonArray("warnings").size() > 0) {
            System.out.println("Warnings:");
            validation.getAsJsonArray("warnings").forEach(warning -> {
                JsonObject warn = warning.getAsJsonObject();
                System.out.println("  - " + warn.get("field").getAsString() +
                    ": " + warn.get("message").getAsString());
            });
        }

        return validation;
    }

    // Step 4: Send invoice
    public JsonObject sendInvoice(Map<String, Object> invoiceData) throws Exception {
        System.out.println("Step 3: Sending invoice...");

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(DISPATCHER_API_URL + "/api/invoicing"))
            .header("Authorization", "Bearer " + this.jwtToken)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(invoiceData)))
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        JsonObject result = gson.fromJson(response.body(), JsonObject.class);

        if (!result.get("success").getAsBoolean()) {
            throw new Exception(
                "Invoice dispatch failed: " + result.get("message").getAsString() + "\n" +
                "Provider error: " + result.get("providerError").toString()
            );
        }

        System.out.println("Invoice sent successfully!");
        return result;
    }

    // Step 5: Handle response
    public void handleResponse(JsonObject result) {
        System.out.println("\n=== Invoice Dispatch Result ===");
        System.out.println("Dispatch ID: " + result.get("dispatchId").getAsString());

        JsonObject providerResponse = result.getAsJsonObject("providerResponse");
        System.out.println("Invoice ID: " + providerResponse.get("invoiceId").getAsString());
        System.out.println("Status: " + providerResponse.get("status").getAsString());
        System.out.println("Invoice URL: " + providerResponse.get("url").getAsString());

        JsonObject generatedDocument = result.getAsJsonObject("generatedDocument");
        System.out.println("Document URL: " + generatedDocument.get("url").getAsString());
        System.out.println("Document Size: " + generatedDocument.get("size").getAsInt() + " bytes");

        System.out.println("Execution Time: " + result.get("executionTime").getAsDouble() + "s");

        if (result.has("metadata")) {
            System.out.println("\nMetadata:");
            JsonObject metadata = result.getAsJsonObject("metadata");
            metadata.entrySet().forEach(entry -> {
                System.out.println("  " + entry.getKey() + ": " + entry.getValue().getAsString());
            });
        }
    }

    // Main execution
    public void run() {
        try {
            // Step 1: Authenticate
            authenticate();

            // Step 2: Prepare data
            Map<String, Object> invoiceData = prepareInvoiceData();

            // Step 3: Validate
            validateInvoice(invoiceData);

            // Step 4: Send invoice
            JsonObject result = sendInvoice(invoiceData);

            // Step 5: Handle response
            handleResponse(result);

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            System.exit(1);
        }
    }

    // Entry point
    public static void main(String[] args) {
        InvoiceDispatcher dispatcher = new InvoiceDispatcher();
        dispatcher.run();
    }
}

Provider-Specific Notes

Different invoicing providers have unique features and requirements. Here's what you need to know for each.

iPaidThat

Provider name: ipaidthat

Features:

• Full invoicing, quotes, and credit notes support

• No e-invoicing support (use INVOICE not E_INVOICE)

• Sandbox environment available for testing

Specific requirements:

• Customer email required

• Invoice number must be unique per company

• Supports French invoicing requirements

Example:

{
  "providerName": "ipaidthat",
  "documentType": "INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "IPT-2026-001",
      "customer": {
        "email": "[email protected]"
      }
    }
  }
}

Best for:

• French companies

• Standard invoicing workflows

• Integration with iPaidThat accounting

Qonto

Provider name: qonto

Features:

• Full invoicing, quotes, and credit notes

• E-invoicing support for France

• Sandbox environment available (use sandbox: true in config)

• Real-time invoice status updates

• Customer portal for payment

Specific requirements:

• IBAN required for bank transfer invoices

• Supports multiple payment methods

• Customer VAT number validated for B2B

Sandbox mode:

{
  "providerName": "qonto",
  "documentType": "INVOICE",
  "template": {...},
  "sandbox": true
}

Example:

{
  "providerName": "qonto",
  "documentType": "INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "QONTO-2026-001",
      "customer": {
        "name": "Acme Corp",
        "vatNumber": "FR12345678901"
      },
      "paymentMethod": "bank_transfer",
      "iban": "FR7630006000011234567890189"
    }
  }
}

Best for:

• French businesses using Qonto banking

• E-invoicing compliance (Chorus Pro)

• Automated payment reconciliation

• Testing with sandbox

Qonto Sandbox: Use sandbox: true in your request to test without creating real invoices. Perfect for development and testing. See Qonto provider docs for details.

PennyLane

Provider name: pennylane

Features:

• Complete invoicing, quotes, and credit notes

• E-invoicing with automatic Chorus Pro submission

• Multi-currency support

• Advanced tax handling (multiple VAT rates)

• Customer and product catalog integration

Specific requirements:

• Product/service codes for e-invoicing

• Customer SIRET for French B2B

• Detailed tax breakdowns

Example:

{
  "providerName": "pennylane",
  "documentType": "E_INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "PL-2026-001",
      "customer": {
        "name": "Acme Corp",
        "siret": "12345678901234",
        "vatNumber": "FR12345678901"
      },
      "items": [
        {
          "description": "Web Development",
          "productCode": "WEBDEV",
          "quantity": 10,
          "unitPrice": 150.00,
          "vatRate": 0.20
        }
      ]
    }
  }
}

Best for:

• E-invoicing compliance (automatic Chorus Pro)

• Complex tax scenarios

• Multi-currency businesses

• Product catalog management

SuperPDP

Provider name: superpdp

Features:

• Full invoicing and quotes

• Credit note support

• E-invoicing with PDP platform

• Integration with French tax authorities

• Automatic archiving

Specific requirements:

• Detailed customer address for legal compliance

• SIRET/SIREN for French companies

• Specific format for credit notes (reference to original invoice)

Example:

{
  "providerName": "superpdp",
  "documentType": "INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "SPDP-2026-001",
      "customer": {
        "name": "Acme Corp",
        "siret": "12345678901234",
        "address": "123 Main St",
        "postalCode": "75001",
        "city": "Paris",
        "country": "FR"
      }
    }
  }
}

Best for:

• French e-invoicing compliance

• Public sector invoicing (PPP)

• Automatic tax archiving

• Legal document retention

Provider Comparison

Feature	iPaidThat	Qonto	PennyLane	SuperPDP
Standard Invoice	✅	✅	✅	✅
E-Invoice	❌	✅	✅	✅
Quotes	✅	✅	✅	✅
Credit Notes	✅	✅	✅	✅
Sandbox	✅	✅	✅	✅
Multi-currency	❌	✅	✅	❌
Webhooks	❌	❌	❌	❌
Chorus Pro	❌	✅	✅	✅
Best for	Simple invoicing	Banking integration	Advanced features	Government/PPP

Async Mode (Using Webhooks)

For production environments, async mode with webhooks is recommended for better scalability and resilience.

Enable Async Mode

Add ?async=true to the endpoint URL:

POST /api/invoicing?async=true

Provide Callback URL

{
  "providerName": "qonto",
  "documentType": "INVOICE",
  "template": {...},
}

Implement Webhook Handler

Your webhook endpoint must:

1. Return 200 OK quickly (< 10 seconds)

2. Handle duplicate events (idempotency)

3. Verify webhook signature (recommended)

4. Process async (don't block the response)

Node.js webhook handler:

const express = require('express');
const app = express();

app.use(express.json());

// Track processed webhooks (use database in production)
const processedWebhooks = new Set();

app.post('/webhooks/dispatcher', async (req, res) => {
  const webhook = req.body;
  const { dispatchId, event, status } = webhook;

  // Return 200 OK immediately
  res.status(200).json({ received: true });

  // Check for duplicates
  if (processedWebhooks.has(dispatchId)) {
    console.log('Duplicate webhook, skipping:', dispatchId);
    return;
  }

  // Mark as processed
  processedWebhooks.add(dispatchId);

  // Process webhook async
  try {
    if (event === 'dispatch_completed' && status === 'success') {
      await handleInvoiceSuccess(webhook);
    } else if (event === 'dispatch_failed') {
      await handleInvoiceFailure(webhook);
    }
  } catch (error) {
    console.error('Webhook processing error:', error);
  }
});

async function handleInvoiceSuccess(webhook) {
  const { dispatchId, data } = webhook;

  console.log('Invoice sent successfully!');
  console.log('Dispatch ID:', dispatchId);
  console.log('Invoice ID:', data.providerResponse.invoiceId);
  console.log('Invoice URL:', data.providerResponse.url);

  // Update your database
  await database.updateInvoice(dispatchId, {
    status: 'sent',
    providerInvoiceId: data.providerResponse.invoiceId,
    invoiceUrl: data.providerResponse.url,
    documentUrl: data.generatedDocument.url
  });

  // Notify customer
  await emailService.send({
    to: data.metadata.customerEmail,
    subject: 'Your Invoice is Ready',
    body: `Your invoice has been generated. View it here: ${data.providerResponse.url}`
  });
}

async function handleInvoiceFailure(webhook) {
  const { dispatchId, error } = webhook;

  console.error('Invoice dispatch failed:', error.message);

  // Update database
  await database.updateInvoice(dispatchId, {
    status: 'failed',
    error: error.message
  });

  // Alert admin
  await alertService.notify({
    level: 'error',
    message: `Invoice dispatch ${dispatchId} failed: ${error.message}`,
    data: error
  });
}

app.listen(3000);

More on async mode:

• Async Flow recipe

• Webhook fundamentals

• Invoicing webhook events

Error Handling

Implement robust error handling for production reliability.

Common Errors

1. Validation Errors (400)

Cause: Invalid request format or missing required fields

{
  "success": false,
  "error": "validation_error",
  "message": "Missing required field: template.data.customer.email",
  "field": "template.data.customer.email"
}

Solution:

• Use validation endpoint first

• Check required fields for your provider

• Verify template data schema

2. Authentication Errors (401)

Cause: Missing, invalid, or expired Basic Auth credentials

{
  "error": "unauthorized",
  "message": "Invalid or expired Basic Auth credentials"
}

Solution:

• Refresh Basic Auth credentials (120min expiry)

• Re-authenticate if refresh fails

• Store token expiration and check before requests

3. Template Not Found (404)

Cause: Template ID doesn't exist or not accessible

{
  "success": false,
  "error": "template_not_found",
  "message": "Template with ID 999 not found or not accessible"
}

Solution:

• Verify template ID in Templater UI

• Check template belongs to your company

• Ensure template is not deleted

4. Provider Errors (422)

Cause: Provider API rejected the request

{
  "success": false,
  "error": "provider_error",
  "message": "Invoice creation failed: Duplicate invoice number",
  "providerError": {
    "code": "DUPLICATE_INVOICE",
    "message": "Invoice INV-2026-001 already exists",
    "details": {
      "existingInvoiceId": "qonto_inv_123"
    }
  }
}

Solution:

• Check provider-specific requirements

• Use unique invoice numbers

• Verify customer data format

• Check provider documentation

5. Timeout Errors (504)

Cause: Operation took longer than 120 seconds (sync mode only)

{
  "success": false,
  "error": "timeout",
  "message": "Request timed out after 120 seconds",
  "suggestion": "Use async mode for long-running operations"
}

Solution:

• Use async mode (?async=true)

• Reduce document size/complexity

• Contact support if timeout persists

Error Handling Example

async function sendInvoiceWithErrorHandling(invoiceData) {
  try {
    // Step 1: Validate first
    const validation = await validateInvoice(invoiceData);

    if (!validation.valid) {
      // Handle validation errors
      console.error('Validation failed:');
      validation.errors.forEach(err => {
        console.error(`  ${err.field}: ${err.message}`);
      });
      throw new ValidationError(validation.errors);
    }

    // Step 2: Send invoice
    const response = await fetch(
      'https://api.docs-dispatcher.io/api/invoicing',
      {
        method: 'POST',
        headers: {
          'Authorization': authHeader,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(invoiceData)
      }
    );

    const result = await response.json();

    // Step 3: Handle response
    if (!response.ok) {
      switch (response.status) {
        case 400:
          throw new ValidationError(result.message);
        case 401:
          // Token expired, refresh and retry
          await refreshJwtToken();
          return sendInvoiceWithErrorHandling(invoiceData);
        case 404:
          throw new TemplateNotFoundError(result.message);
        case 422:
          throw new ProviderError(result.providerError);
        case 504:
          // Timeout, switch to async
          console.warn('Timeout detected, switching to async mode');
          return sendInvoiceAsync(invoiceData);
        default:
          throw new DispatchError(result.message);
      }
    }

    if (!result.success) {
      throw new DispatchError(result.message);
    }

    return result;

  } catch (error) {
    // Log error
    logger.error('Invoice dispatch failed', {
      error: error.message,
      invoiceData: invoiceData,
      timestamp: new Date().toISOString()
    });

    // Handle specific error types
    if (error instanceof ValidationError) {
      // Show user-friendly validation errors
      showValidationErrors(error.errors);
    } else if (error instanceof ProviderError) {
      // Provider-specific error handling
      handleProviderError(error);
    } else {
      // Generic error handling
      showGenericError(error.message);
    }

    throw error;
  }
}

Troubleshooting Common Issues

Issue 1: "Template not found"

Symptoms:

• 404 error when dispatching

• Message: "Template with ID XXX not found"

Causes:

• Wrong template ID

• Template deleted

• Template belongs to different company

• User lacks access to template

Solutions:

1. Verify template ID in Templater UI

2. Check template exists: GET /api/v1/templates/{id}

3. Ensure template belongs to your company

4. Check user permissions

Issue 2: "Duplicate invoice number"

Symptoms:

• Provider error: "Invoice already exists"

• Message mentions invoice number conflict

Causes:

• Invoice number already used in provider

• Multiple simultaneous requests with same number

Solutions:

1. Use unique invoice numbers (timestamp, UUID, counter)

2. Check existing invoices before dispatch

3. Implement retry with new number

4. Use provider's invoice number validation API

Issue 3: "Invalid customer data"

Symptoms:

• Validation error on customer fields

• Provider rejects customer information

Causes:

• Missing required customer fields

• Invalid email format

• Invalid address/postal code

• Wrong country code format

Solutions:

1. Validate customer data before dispatch

2. Use proper country codes (ISO 3166-1 alpha-2: FR, US, etc.)

3. Validate email format

4. Include all required fields for your provider

Issue 4: "Token expired"

Symptoms:

• 401 Unauthorized error

• Message: "Invalid or expired Basic Auth credentials"

Causes:

• Basic Auth credentials older than 120 minutes

• System clock skew

• Token not refreshed

Solutions:

1. Implement token refresh logic

2. Store token expiration timestamp

3. Refresh token before expiry (10min buffer)

4. Re-authenticate if refresh fails

async function ensureValidToken() {
  const expiresAt = new Date(tokenExpiresAt);
  const now = new Date();
  const minutesUntilExpiry = (expiresAt - now) / 1000 / 60;

  if (minutesUntilExpiry < 10) {
    // Refresh token
    await refreshJwtToken();
  }

  return jwtToken;
}

Issue 5: "Calculation mismatch"

Symptoms:

• Validation error: "Total doesn't match subtotal + tax"

• Provider rejects invoice due to amount discrepancy

Causes:

• Rounding errors in calculations

• Incorrect tax rate application

• Item totals don't sum to subtotal

Solutions:

1. Use decimal-safe math libraries

2. Round consistently (2 decimal places for currency)

3. Validate calculations before dispatch

4. Use provider's calculation rules

// Example: Safe calculation
function calculateInvoiceTotals(items, taxRate) {
  const subtotal = items.reduce((sum, item) => {
    return sum + (item.quantity * item.unitPrice);
  }, 0);

  const taxAmount = Math.round(subtotal * taxRate * 100) / 100;
  const total = Math.round((subtotal + taxAmount) * 100) / 100;

  return {
    subtotal: Math.round(subtotal * 100) / 100,
    taxAmount,
    total
  };
}

What Happens Behind the Scenes

Understanding the complete workflow helps troubleshoot issues and optimize your integration.

Complete Dispatch Flow

1. Client → Dispatcher API
   └─ Authenticate → Get JWT

2. Client → Dispatcher API
   └─ POST /api/invoicing/validate
      ├─ Parse request
      ├─ Check JWT validity
      ├─ Validate request structure
      ├─ Check template exists
      ├─ Validate template data schema
      └─ Return validation result

3. Client → Dispatcher API
   └─ POST /api/invoicing
      ├─ Parse request
      ├─ Check JWT validity
      ├─ Load provider configuration
      ├─ Prepare template data
      │
      ├─ Printer API
      │  └─ Generate document from template
      │     ├─ Fetch template
      │     ├─ Render with data
      │     ├─ Convert to PDF
      │     └─ Upload to storage
      │
      ├─ Provider API (Qonto/PennyLane/etc)
      │  └─ Create invoice
      │     ├─ Validate provider data
      │     ├─ Create invoice record
      │     ├─ Attach generated PDF
      │     └─ Send to customer (optional)
      │
      └─ Return response to client
         ├─ dispatchId
         ├─ providerResponse
         ├─ generatedDocument URL
         └─ metadata

Timing Breakdown

Typical sync mode timing:

• JWT validation: 10-50ms

• Request validation: 50-100ms

• Template loading: 100-200ms

• Document generation: 500-2000ms

• Provider API call: 1000-5000ms

• Total: 1.5-7 seconds

Async mode timing:

• Queue dispatch: 50-200ms

• Background processing: 2-30 seconds

• Webhook delivery: 100-500ms

Resource Usage

What gets created:

1. Generated PDF - Stored in cloud storage (30-day retention)

2. Provider invoice - Created in accounting platform

3. Dispatch record - Tracked in Dispatcher database

4. Audit log - Security and compliance tracking

What gets charged:

• 1 credit per successful invoice dispatch

• 0 credits for validation requests

• 0 credits for failed dispatches (validation errors)

• Credits deducted after successful provider response

Next Steps

Now that you know how to generate and send invoices:

Related Recipes

• Credit Note (Avoir) - Issue refunds and adjustments

• Quote (Devis) - Generate quotes before invoicing

• Validate then Send - Production-ready validation pattern

• Async Flow - Scale with webhooks and background processing

• Email Dispatch - Email invoices to customers

Core Concepts

• Request Model - Understand CompositeRequest structure

• Providers & Configurations - Configure providers

• Sync vs Async - Choose execution mode

• Services - Explore all services

Provider Documentation

• Qonto - Qonto-specific features and sandbox

• PennyLane - PennyLane integration details

• iPaidThat - iPaidThat configuration

• SuperPDP - SuperPDP e-invoicing

SDKs

• Node.js SDK - Pre-built Node.js client

• PHP SDK - PHP integration library

• Java SDK - Java client library

Support

• Check Common Errors for error reference

• See Provider Issues for provider-specific problems

• Use Debug Checklist for systematic troubleshooting

• Contact [email protected] for help

Summary

You've learned how to:

• ✅ Authenticate and obtain Basic Auth credentials

• ✅ Structure invoice requests for different providers

• ✅ Validate requests before sending (safety check)

• ✅ Send invoices in sync and async modes

• ✅ Handle responses and errors gracefully

• ✅ Implement complete workflows in 4 languages

• ✅ Choose the right provider for your needs

• ✅ Troubleshoot common issues

Ready for production? Follow this checklist:

1. Configure your provider credentials (company/user level)

2. Create and test templates in Templater

3. Validate all requests before production dispatch

4. Implement error handling and retry logic

5. Use async mode with webhooks for scalability

6. Monitor dispatch success rates

7. Set up alerts for failures

Happy invoicing!