📋Quote (Devis)

Learn how to generate and dispatch quotes 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 quote generation and dispatch workflow:

Authenticate and set up Basic Authentication
Prepare your quote data with validity period
Validate the request (recommended safety check)
Send the quote to your accounting provider
Handle the response and track status
Convert quote to invoice when accepted

By the end of this guide, you'll have working code to automatically generate and send quotes (devis, estimates, proposals) to providers like Qonto, PennyLane, iPaidThat.

What You'll Learn

How to structure quote requests for different providers
Set validity periods and expiration dates
Convert accepted quotes to invoices
Best practices for quote workflows
Error handling strategies
Provider-specific quote features
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.

What is a Quote?

A quote (devis in French) is a document that:

Proposes services or products with pricing
Commits to specific terms and conditions
Expires after a validity period
Converts to invoice when accepted
Legally binds both parties when signed

Common scenarios:

Project proposals for new clients
Service estimates before work begins
Product pricing for bulk orders
Subscription pricing proposals
Custom solution pricing
RFP responses

Legal Binding: In many jurisdictions, an accepted quote is legally binding. Ensure pricing, terms, and scope are accurate before sending.

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:

Step 2: Prepare Quote Data

Structure your quote data according to the CompositeRequest model. Quotes have specific fields for validity and acceptance tracking.

Basic Quote Structure

{
  "providerName": "qonto",
  "documentType": "QUOTE",
  "template": {
    "id": 125,
    "data": {
      "quoteNumber": "QT-2026-001",
      "date": "2026-02-13",
      "validUntil": "2026-03-13",
      "validityDays": 30,
      "customer": {
        "name": "Acme Corp",
        "email": "[email protected]",
        "contactPerson": "Jane Smith",
        "phone": "+33 1 23 45 67 89",
        "address": "123 Main St",
        "city": "Paris",
        "postalCode": "75001",
        "country": "FR"
      },
      "projectTitle": "Website Redesign & Branding",
      "projectDescription": "Complete website redesign with new branding and logo",
      "items": [
        {
          "description": "Website Redesign - 40 hours",
          "category": "Web Development",
          "quantity": 40,
          "unitPrice": 150.00,
          "total": 6000.00
        },
        {
          "description": "Logo & Brand Identity",
          "category": "Design",
          "quantity": 1,
          "unitPrice": 2000.00,
          "total": 2000.00
        },
        {
          "description": "Content Migration",
          "category": "Web Development",
          "quantity": 10,
          "unitPrice": 100.00,
          "total": 1000.00
        }
      ],
      "subtotal": 9000.00,
      "taxRate": 0.20,
      "taxAmount": 1800.00,
      "total": 10800.00,
      "paymentTerms": "50% upfront, 50% on completion",
      "deliveryTime": "6 weeks from acceptance",
      "conditions": "Quote valid for 30 days. Prices subject to change after expiration."
    }
  },
  "invoicing": {
    "validityPeriod": 30,
    "requiresSignature": true,
    "autoConvertToInvoice": false
  },
  "metadata": {
    "opportunityId": "OPP-2026-456",
    "salesRepId": "REP-123",
    "source": "website"
  }
}

Required Fields

Field

Type

Description

providerName

string

Provider to use: qonto, pennylane, ipaidthat, superpdp

documentType

string

Must be QUOTE for quotes

template.id

number

Template ID from Templater (use quote template)

template.data

object

Template variables (schema depends on template)

template.data.quoteNumber

string

Unique quote identifier

template.data.validUntil

string

Quote expiration date (ISO 8601)

Quote-Specific Fields

Field

Type

Description

template.data.validityDays

number

Number of days quote is valid

template.data.projectTitle

string

Project/proposal title

template.data.projectDescription

string

Detailed project description

template.data.deliveryTime

string

Estimated delivery timeframe

template.data.paymentTerms

string

Payment schedule and terms

template.data.conditions

string

Terms and conditions

invoicing.validityPeriod

number

Validity in days (provider field)

invoicing.requiresSignature

boolean

Whether signature required

invoicing.autoConvertToInvoice

boolean

Auto-convert when accepted

Validity Period Options

Fixed Date:

{
  "template": {
    "data": {
      "validUntil": "2026-03-13"
    }
  }
}

Days from Creation:

{
  "template": {
    "data": {
      "validityDays": 30
    }
  },
  "invoicing": {
    "validityPeriod": 30
  }
}

Common validity periods:

15 days - Fast-moving sales
30 days - Standard quotes
60 days - Complex projects
90 days - Enterprise proposals

Payment Terms Examples

{
  "paymentTerms": "Net 30"
}

{
  "paymentTerms": "50% upfront, 50% on delivery"
}

{
  "paymentTerms": "Monthly installments over 6 months"
}

{
  "paymentTerms": "25% deposit, 50% at milestone, 25% completion"
}

Step 3: Validate Request (Recommended)

Before sending real quotes, validate your request structure.

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": "QUOTE",
    "template": {
      "id": 125,
      "data": {
        "quoteNumber": "QT-2026-001",
        "date": "2026-02-13",
        "validUntil": "2026-03-13",
        "customer": {
          "name": "Acme Corp",
          "email": "[email protected]"
        },
        "items": [
          {
            "description": "Website Redesign",
            "quantity": 40,
            "unitPrice": 150.00,
            "total": 6000.00
          }
        ],
        "total": 7200.00
      }
    },
    "invoicing": {
      "validityPeriod": 30,
      "requiresSignature": true
    }
  }'

Validation Success Response

{
  "valid": true,
  "message": "Quote request is valid and ready for dispatch",
  "warnings": [
    {
      "field": "template.data.validUntil",
      "message": "Quote will expire in 28 days",
      "level": "info"
    }
  ]
}

Validation Error Response

{
  "valid": false,
  "errors": [
    {
      "field": "template.data.validUntil",
      "message": "Valid until date must be in the future",
      "value": "2026-01-01"
    },
    {
      "field": "template.data.customer.email",
      "message": "Customer email is required for quote notifications",
      "value": null
    }
  ]
}

Step 4: Send Quote (Real Dispatch)

Once validation passes, send the actual quote.

Sync Mode (Default)

curl -X POST https://api.docs-dispatcher.io/api/invoicing \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "providerName": "qonto",
    "documentType": "QUOTE",
    "template": {
      "id": 125,
      "data": {
        "quoteNumber": "QT-2026-001",
        "date": "2026-02-13",
        "validUntil": "2026-03-13",
        "validityDays": 30,
        "customer": {
          "name": "Acme Corp",
          "email": "[email protected]",
          "contactPerson": "Jane Smith",
          "address": "123 Main St, Paris"
        },
        "projectTitle": "Website Redesign & Branding",
        "items": [
          {
            "description": "Website Redesign - 40 hours",
            "quantity": 40,
            "unitPrice": 150.00,
            "total": 6000.00
          },
          {
            "description": "Logo & Brand Identity",
            "quantity": 1,
            "unitPrice": 2000.00,
            "total": 2000.00
          }
        ],
        "subtotal": 8000.00,
        "taxRate": 0.20,
        "taxAmount": 1600.00,
        "total": 9600.00,
        "paymentTerms": "50% upfront, 50% on completion",
        "deliveryTime": "6 weeks from acceptance"
      }
    },
    "invoicing": {
      "validityPeriod": 30,
      "requiresSignature": true,
      "autoConvertToInvoice": false
    },
    "metadata": {
      "opportunityId": "OPP-2026-456",
      "salesRepId": "REP-123"
    }
  }'

Success Response:

{
  "success": true,
  "dispatchId": "disp_quote_abc789xyz",
  "providerResponse": {
    "quoteId": "qonto_quote_123",
    "quoteNumber": "QT-2026-001",
    "status": "sent",
    "url": "https://qonto.com/quotes/123",
    "signatureUrl": "https://qonto.com/quotes/123/sign",
    "validUntil": "2026-03-13T23:59:59Z",
    "createdAt": "2026-02-13T12:30:00Z"
  },
  "generatedDocument": {
    "url": "https://storage.docs-dispatcher.io/quotes/QT-2026-001.pdf",
    "size": 312456,
    "contentType": "application/pdf",
    "expiresAt": "2026-03-13T12:30:00Z"
  },
  "metadata": {
    "opportunityId": "OPP-2026-456",
    "salesRepId": "REP-123"
  },
  "executionTime": 2.5
}

Provider Response Fields

Field

Description

quoteId

Provider's unique quote ID

quoteNumber

Quote number (your format)

status

Quote status: sent, viewed, accepted, rejected, expired

url

Quote viewing URL

signatureUrl

URL for customer to sign/accept quote

validUntil

Quote expiration timestamp

Step 5: Track Quote Status

After sending, track quote status through provider webhooks or polling.

Quote Lifecycle States

┌─────────┐
│  SENT   │ ← Initial state after dispatch
└────┬────┘
     │
     ├──→ VIEWED    (customer opened quote)
     │
     ├──→ ACCEPTED  (customer signed/accepted)
     │       │
     │       └──→ CONVERTED (to invoice)
     │
     ├──→ REJECTED  (customer declined)
     │
     └──→ EXPIRED   (validity period passed)

Check Quote Status (Provider API)

Most providers offer status webhooks. Example webhook payload:

{
  "event": "quote_accepted",
  "quoteId": "qonto_quote_123",
  "quoteNumber": "QT-2026-001",
  "status": "accepted",
  "acceptedAt": "2026-02-20T15:30:00Z",
  "acceptedBy": "Jane Smith",
  "signature": {
    "signedAt": "2026-02-20T15:30:00Z",
    "ipAddress": "203.0.113.42",
    "signatureUrl": "https://qonto.com/signatures/sig_xyz"
  }
}

Step 6: Convert Quote to Invoice

When a quote is accepted, convert it to an invoice.

Manual Conversion

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-20",
        "quotedReference": {
          "quoteNumber": "QT-2026-001",
          "quoteId": "qonto_quote_123",
          "acceptedDate": "2026-02-20"
        },
        "customer": {...},
        "items": [...],
        "total": 9600.00
      }
    },
    "invoicing": {
      "convertedFromQuote": "qonto_quote_123"
    }
  }'

Auto-Conversion

Enable automatic conversion when quote is accepted:

{
  "invoicing": {
    "autoConvertToInvoice": true,
    "invoiceTemplate": 123
  }
}

When quote is accepted, provider automatically creates invoice using same items/amounts.

Complete Examples

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 quote data
QUOTE_REQUEST='{
  "providerName": "qonto",
  "documentType": "QUOTE",
  "template": {
    "id": 125,
    "data": {
      "quoteNumber": "QT-2026-001",
      "date": "2026-02-13",
      "validUntil": "2026-03-13",
      "validityDays": 30,
      "customer": {
        "name": "Acme Corp",
        "email": "[email protected]",
        "contactPerson": "Jane Smith",
        "address": "123 Main St, Paris"
      },
      "projectTitle": "Website Redesign & Branding",
      "items": [
        {
          "description": "Website Redesign - 40 hours",
          "quantity": 40,
          "unitPrice": 150.00,
          "total": 6000.00
        },
        {
          "description": "Logo & Brand Identity",
          "quantity": 1,
          "unitPrice": 2000.00,
          "total": 2000.00
        }
      ],
      "subtotal": 8000.00,
      "taxRate": 0.20,
      "taxAmount": 1600.00,
      "total": 9600.00,
      "paymentTerms": "50% upfront, 50% on completion",
      "deliveryTime": "6 weeks from acceptance"
    }
  },
  "invoicing": {
    "validityPeriod": 30,
    "requiresSignature": true
  },
  "metadata": {
    "opportunityId": "OPP-2026-456"
  }
}'

# Step 3: Validate
echo "Step 2: Validating quote request..."
VALIDATION_RESPONSE=$(curl -s -X POST https://api.docs-dispatcher.io/api/invoicing/validate \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d "$QUOTE_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 quote
echo "Step 3: Sending quote..."
DISPATCH_RESPONSE=$(curl -s -X POST https://api.docs-dispatcher.io/api/invoicing \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d "$QUOTE_REQUEST")

# Step 5: Handle response
SUCCESS=$(echo $DISPATCH_RESPONSE | jq -r '.success')
if [ "$SUCCESS" = "true" ]; then
  echo "Quote sent successfully!"
  echo "Dispatch ID: $(echo $DISPATCH_RESPONSE | jq -r '.dispatchId')"
  echo "Quote ID: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.quoteId')"
  echo "Quote URL: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.url')"
  echo "Signature URL: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.signatureUrl')"
  echo "Valid Until: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.validUntil')"
else
  echo "Quote dispatch failed:"
  echo $DISPATCH_RESPONSE | jq
  exit 1
fi

Node.js (Complete Flow)

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

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

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
    })
  });

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

function prepareQuoteData() {
  return {
    providerName: 'qonto',
    documentType: 'QUOTE',
    template: {
      id: 125,
      data: {
        quoteNumber: 'QT-2026-001',
        date: '2026-02-13',
        validUntil: '2026-03-13',
        validityDays: 30,
        customer: {
          name: 'Acme Corp',
          email: '[email protected]',
          contactPerson: 'Jane Smith',
          address: '123 Main St, Paris'
        },
        projectTitle: 'Website Redesign & Branding',
        items: [
          {
            description: 'Website Redesign - 40 hours',
            quantity: 40,
            unitPrice: 150.00,
            total: 6000.00
          },
          {
            description: 'Logo & Brand Identity',
            quantity: 1,
            unitPrice: 2000.00,
            total: 2000.00
          }
        ],
        subtotal: 8000.00,
        taxRate: 0.20,
        taxAmount: 1600.00,
        total: 9600.00,
        paymentTerms: '50% upfront, 50% on completion',
        deliveryTime: '6 weeks from acceptance'
      }
    },
    invoicing: {
      validityPeriod: 30,
      requiresSignature: true
    },
    metadata: {
      opportunityId: 'OPP-2026-456'
    }
  };
}

async function validateQuote(jwtToken, quoteData) {
  console.log('Step 2: Validating quote request...');

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

  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!');
  return validation;
}

async function sendQuote(jwtToken, quoteData) {
  console.log('Step 3: Sending quote...');

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

  const result = await response.json();

  if (!result.success) {
    throw new Error(`Quote dispatch failed: ${result.message}`);
  }

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

function handleResponse(result) {
  console.log('\n=== Quote Dispatch Result ===');
  console.log(`Dispatch ID: ${result.dispatchId}`);
  console.log(`Quote ID: ${result.providerResponse.quoteId}`);
  console.log(`Status: ${result.providerResponse.status}`);
  console.log(`Quote URL: ${result.providerResponse.url}`);
  console.log(`Signature URL: ${result.providerResponse.signatureUrl}`);
  console.log(`Valid Until: ${result.providerResponse.validUntil}`);
  console.log(`Document URL: ${result.generatedDocument.url}`);
}

async function main() {
  try {
    const email = process.env.DOCS_DISPATCHER_EMAIL;
const password = process.env.DOCS_DISPATCHER_PASSWORD;
const authHeader = createBasicAuthHeader(email, password);
// await authenticate();
    const quoteData = prepareQuoteData();
    await validateQuote(jwtToken, quoteData);
    const result = await sendQuote(jwtToken, quoteData);
    handleResponse(result);
  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

main();

PHP (Complete Flow)

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

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

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 QuoteDispatcher {
    private $client;
    private $jwtToken;

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

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

        $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\n";
        return $this->jwtToken;
    }

    public function prepareQuoteData() {
        return [
            'providerName' => 'qonto',
            'documentType' => 'QUOTE',
            'template' => [
                'id' => 125,
                'data' => [
                    'quoteNumber' => 'QT-2026-001',
                    'date' => '2026-02-13',
                    'validUntil' => '2026-03-13',
                    'validityDays' => 30,
                    'customer' => [
                        'name' => 'Acme Corp',
                        'email' => '[email protected]',
                        'contactPerson' => 'Jane Smith'
                    ],
                    'projectTitle' => 'Website Redesign & Branding',
                    'items' => [
                        [
                            'description' => 'Website Redesign - 40 hours',
                            'quantity' => 40,
                            'unitPrice' => 150.00,
                            'total' => 6000.00
                        ]
                    ],
                    'total' => 7200.00,
                    'paymentTerms' => '50% upfront, 50% on completion'
                ]
            ],
            'invoicing' => [
                'validityPeriod' => 30,
                'requiresSignature' => true
            ]
        ];
    }

    public function validateQuote($quoteData) {
        echo "Step 2: Validating quote...\n";

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

        $validation = json_decode($response->getBody(), true);
        if (!$validation['valid']) {
            throw new Exception('Validation failed');
        }
        echo "Validation passed!\n";
        return $validation;
    }

    public function sendQuote($quoteData) {
        echo "Step 3: Sending quote...\n";

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

        $result = json_decode($response->getBody(), true);
        echo "Quote sent successfully!\n";
        return $result;
    }

    public function run() {
        try {
            $this->authenticate();
            $quoteData = $this->prepareQuoteData();
            $this->validateQuote($quoteData);
            $result = $this->sendQuote($quoteData);

            echo "\n=== Quote Sent ===\n";
            echo "Quote ID: {$result['providerResponse']['quoteId']}\n";
            echo "Quote URL: {$result['providerResponse']['url']}\n";
        } catch (Exception $e) {
            echo "Error: " . $e->getMessage() . "\n";
            exit(1);
        }
    }
}

$dispatcher = new QuoteDispatcher();
$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.*;

public class QuoteDispatcher {
    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 final HttpClient client;
    private final Gson gson;
    private String jwtToken;

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

    public String authenticate() throws Exception {
        System.out.println("Authenticating...");

        Map<String, String> authData = new HashMap<>();
        authData.put("email", "[email protected]");
        authData.put("password", "your-secure-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());
        JsonObject data = gson.fromJson(response.body(), JsonObject.class);
        this.jwtToken = data.get("token").getAsString();

        System.out.println("Authenticated successfully");
        return this.jwtToken;
    }

    public Map<String, Object> prepareQuoteData() {
        Map<String, Object> quote = new HashMap<>();
        quote.put("providerName", "qonto");
        quote.put("documentType", "QUOTE");

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

        Map<String, Object> data = new HashMap<>();
        data.put("quoteNumber", "QT-2026-001");
        data.put("date", "2026-02-13");
        data.put("validUntil", "2026-03-13");
        data.put("total", 9600.00);

        template.put("data", data);
        quote.put("template", template);

        return quote;
    }

    public JsonObject sendQuote(Map<String, Object> quoteData) throws Exception {
        System.out.println("Sending quote...");

        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(quoteData)))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        JsonObject result = gson.fromJson(response.body(), JsonObject.class);

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

    public void run() {
        try {
            authenticate();
            Map<String, Object> quoteData = prepareQuoteData();
            JsonObject result = sendQuote(quoteData);

            System.out.println("\n=== Quote Sent ===");
            System.out.println("Quote ID: " +
                result.getAsJsonObject("providerResponse").get("quoteId").getAsString());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            System.exit(1);
        }
    }

    public static void main(String[] args) {
        new QuoteDispatcher().run();
    }
}

Provider-Specific Notes

Qonto

Quote Features:

Full quote support with signature tracking
Customer portal for acceptance
Auto-conversion to invoice optional
Sandbox mode available

Specific requirements:

Validity period required
Customer email required for signature link

PennyLane

Quote Features:

Comprehensive quote management
Signature tracking
Multiple quote versions
Automatic invoice conversion

iPaidThat

Quote Features:

Standard quote support
Email delivery
Acceptance tracking

SuperPDP

Quote Features:

Quote support with archiving
Legal compliance
E-signature integration

Provider Comparison

Feature

iPaidThat

Qonto

PennyLane

SuperPDP

Quotes

✅

E-Signature

❌

✅

Auto-Convert

❌

✅

⚠️ Manual

Validity Tracking

✅

Customer Portal

❌

✅

Quote Versions

❌

⚠️ Limited

✅

❌

Error Handling

Common Quote Errors

1. Expired Validity Date

{
  "valid": false,
  "errors": [
    {
      "field": "template.data.validUntil",
      "message": "Valid until date must be in the future"
    }
  ]
}

Solution: Use future date for validUntil

2. Missing Customer Email

{
  "error": "validation_error",
  "message": "Customer email required for quote signature"
}

Solution: Include customer.email in template data

Next Steps

Invoice - Convert quotes to invoices
Credit Note - Handle quote rejections
Validate then Send - Validation best practices

Core Concepts

Summary

You've learned how to:

✅ Structure quote requests with validity periods
✅ Send quotes to customers
✅ Track quote status and acceptance
✅ Convert accepted quotes to invoices
✅ Implement complete workflows in 4 languages

Happy quoting!

PreviousCredit Note (Avoir)NextValidate then Send

Last updated 5 days ago

hashtagOverview

hashtagWhat You'll Learn

hashtagPrerequisites

hashtagWhat is a Quote?

hashtagStep 1: Authentication

hashtagSetup Credentials

hashtagStep 2: Prepare Quote Data

hashtagBasic Quote Structure

hashtagRequired Fields

hashtagQuote-Specific Fields

hashtagValidity Period Options

hashtagPayment Terms Examples

hashtagStep 3: Validate Request (Recommended)

hashtagValidation Request

hashtagValidation Success Response

hashtagValidation Error Response

hashtagStep 4: Send Quote (Real Dispatch)

hashtagSync Mode (Default)

hashtagProvider Response Fields

hashtagStep 5: Track Quote Status

hashtagQuote Lifecycle States

hashtagCheck Quote Status (Provider API)

hashtagStep 6: Convert Quote to Invoice

hashtagManual Conversion

hashtagAuto-Conversion

hashtagComplete Examples

hashtagcurl (Complete Flow)

hashtagNode.js (Complete Flow)

hashtagPHP (Complete Flow)

hashtagJava (Complete Flow)

hashtagProvider-Specific Notes

hashtagQonto

hashtagPennyLane

hashtagiPaidThat

hashtagSuperPDP

hashtagProvider Comparison

hashtagError Handling

hashtagCommon Quote Errors

hashtag1. Expired Validity Date

hashtag2. Missing Customer Email

hashtagNext Steps

hashtagRelated Recipes

hashtagCore Concepts

hashtagSummary

Overview

What You'll Learn

Prerequisites

What is a Quote?

Step 1: Authentication

Setup Credentials

Step 2: Prepare Quote Data

Basic Quote Structure

Required Fields

Quote-Specific Fields

Validity Period Options

Payment Terms Examples

Step 3: Validate Request (Recommended)

Validation Request

Validation Success Response

Validation Error Response

Step 4: Send Quote (Real Dispatch)

Sync Mode (Default)

Provider Response Fields

Step 5: Track Quote Status

Quote Lifecycle States

Check Quote Status (Provider API)

Step 6: Convert Quote to Invoice

Manual Conversion

Auto-Conversion

Complete Examples

curl (Complete Flow)

Node.js (Complete Flow)

PHP (Complete Flow)

Java (Complete Flow)

Provider-Specific Notes

Qonto

PennyLane

iPaidThat

SuperPDP

Provider Comparison

Error Handling

Common Quote Errors

1. Expired Validity Date

2. Missing Customer Email

Next Steps

Related Recipes

Core Concepts

Summary