ERP Integration

Zucchetti API integration: invoice, delivery-note and order data written straight into your ERP

Looking for a Zucchetti integration that gets invoice, delivery-note and order data into your ERP without manual data entry? Data Alchemy extracts data from your documents with AI, validates it against master data and writes it into Zucchetti in about 3 seconds via REST API, webhooks and SQL queries.

Request a demo All ERP integrations →

99.8%Data accuracy

~3sPer document

REST/SQLZucchetti channels

0Manual data entry

Context

Why integrate Zucchetti with an IDP engine

Zucchetti (Ad Hoc, Mago, Infinity) is one of the most widely used management systems among Italian SMEs, but the accounts-payable cycle still requires manually entering invoices, delivery notes and orders. Intelligent Document Processing software integrated with Zucchetti reduces manual data entry and feeds the system in real time: every document is read, extracted and written into Zucchetti without typing, eliminating the errors, delays and reconciliations that weigh on the back office.

Data Alchemy's Zucchetti integration removes that work: Intelligent Document Processing reads the document, extracts the fields, checks them against Zucchetti master data (vendors, items, terms) and writes the record straight into the system, ready to be posted.

This direct link, with no third-party middleware in between, is what we mean by native integration: the full explanation, including how it differs from file-based and middleware integration, is on the dedicated page.

How it connects

Supported Zucchetti integration methods

Extracted data reaches Zucchetti through the channel that best fits your installation, with no need to build connectors from scratch.

REST API

Validated documents are sent to Zucchetti via REST API in real time, mapped to the invoice, order and delivery-note fields of your environment.

Webhooks and events

Each processed document triggers a webhook: Zucchetti receives the payload as soon as extraction completes, for event-driven flows with no polling.

SQL queries and writes

For Zucchetti installations with database access, data is written via parameterized SQL queries to dedicated tables and staging areas.

Validation on Zucchetti master data

Before writing, data is matched against Zucchetti master data — vendors, item codes, open orders — to ensure consistency and correct matching.

Technical requirements

Zucchetti API documentation and technical requirements

The integration relies on Zucchetti's REST API (or, where available, database access) to write accounts-payable records. There's no need to build connectors or study Zucchetti's API documentation in detail: Data Alchemy handles authentication, field mapping and error handling, adapting to your installation's configuration (cloud or on-premise). Our technical team defines endpoints, credentials and staging tables with you during onboarding.

API examples

Zucchetti API: endpoints, JSON payload and field mapping

The flow is the same as Data Alchemy's data extraction API: submit the document with a POST setting erp_target=zucchetti and receive structured JSON — via webhook or with a GET on /v1/documents/{id} — already validated against Zucchetti master data and ready to write into the ERP.

Request — submit invoice for Zucchetti (cURL)

curl -X POST https://api.data-alchemy.ai/v1/documents \
  -H "Authorization: Bearer $DATA_ALCHEMY_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@fattura.pdf" \
  -F "document_type=invoice" \
  -F "erp_target=zucchetti"

Webhook payload — document ready for Zucchetti

{
  "event": "document.processed",
  "id": "doc_8a7f2c91",
  "status": "completed",
  "erp_target": "zucchetti",
  "data": {
    "header": {
      "supplier": {
        "name": "Rossi Forniture S.r.l.",
        "vat_number": "IT01234567890"
      },
      "invoice_number": "2026/00417",
      "issue_date": "2026-05-28"
    },
    "line_items": [
      {
        "sku": "ART-0042",
        "quantity": 12,
        "unit_price": 8.50,
        "vat_rate": 22
      }
    ],
    "totals": { "net": 102.00, "vat": 22.44, "gross": 124.44 },
    "validation": { "status": "validated", "erp_match": true }
  }
}

Webhooks: write to Zucchetti without polling

Register your endpoint with a POST to /v1/webhooks and you'll receive the document.processed event as soon as extraction completes, with no interval polling. Every request is signed with HMAC SHA-256 in the X-Data-Alchemy-Signature header: verify the signature before writing the record into Zucchetti. If your endpoint is unreachable, delivery is retried with increasing backoff, so no document is lost.

Field mapping to Zucchetti master data

Fields from the extracted JSON are mapped onto their Zucchetti counterparts. Validation happens before the write: if the VAT number has no match in the vendor master data, or an item code does not exist, the document is flagged instead of creating an inconsistent record.

Data Alchemy JSON fieldDestination in Zucchetti

header.supplier.vat_numberVendor master data — VAT number (match key)

header.supplier.nameVendor master data — Company name

header.invoice_numberDocument header — Document number

header.issue_dateDocument header — Document date

line_items[].skuDocument lines — Item code (item master data)

line_items[].quantityDocument lines — Quantity

line_items[].unit_priceDocument lines — Unit price

line_items[].vat_rateDocument lines — VAT rate

totals.net / totals.vat / totals.grossDocument header — Net, tax and gross total

validation.erp_matchValidation result: true writes the record, false sends it to review

Full API documentation

Authentication and limits

Zucchetti API: authentication, supported formats and rate limits

Integrating Zucchetti via API always means the same Data Alchemy REST endpoint: base URL https://api.data-alchemy.ai/v1, Bearer API key authentication and UTF-8 JSON responses. The authentication flow is identical for invoices, delivery notes and orders headed for the ERP, and does not change between cloud and on-premise Zucchetti installations.

Generate the API key

The key is created from the Data Alchemy console. Keep it server-side and never let it reach the browser or a repository: it identifies your tenant and the write permissions towards Zucchetti.

Authenticate every request

All calls run over HTTPS and carry the Authorization: Bearer $DATA_ALCHEMY_API_KEY header. There is no OAuth flow to implement: the API key is enough to submit documents and read results.

Register the webhook

A POST to /v1/webhooks declares the endpoint that will receive the document.processed event. It is the recommended channel for writing into Zucchetti as soon as extraction is ready, with no polling.

Verify the HMAC signature

Every webhook is signed with HMAC SHA-256 in the X-Data-Alchemy-Signature header. Verify the signature with your endpoint secret before writing any record into Zucchetti.

Supported formats and document types

The POST /v1/documents endpoint accepts the file as multipart/form-data together with the document_type parameter (invoice, delivery_note, order, contract, price_list) and erp_target=zucchetti. Native and scanned PDFs, images and Italian FatturaPA XML e-invoices are supported. The acceptance response is a 202 with the document id; the structured JSON is retrieved with a GET on /v1/documents/{id} or delivered straight to your webhook, already validated against Zucchetti master data.

Status codes and error handling

The API uses standard HTTP status codes and always returns JSON with error.code and error.message. Handling these cases on the integration side stops an unreadable document or an expired key from turning into an inconsistent record inside Zucchetti.

CodeMeaning

202Document accepted and processing.

200Result available and ready for Zucchetti.

401API key missing, expired or invalid.

422Unreadable document or unsupported type.

429Rate limit exceeded: retry with exponential backoff.

On a 429 or any 5xx error, retry with exponential backoff rather than hammering at a fixed interval. Undelivered webhooks are retried automatically with increasing backoff: if the connector towards Zucchetti stays unreachable for a few minutes, no document.processed event is lost. Documents that fail master-data validation are not written into the ERP but sent to review, with the detail of the field that found no match.

Data flow

From document to Zucchetti in four steps

The same flow applies to invoices, delivery notes, orders, contracts and price lists: the document goes in, structured data comes out inside Zucchetti.

Acquisition

The document arrives via email, upload or a monitored folder (Google Workspace, Microsoft 365).

AI extraction

An LLM dedicated to the document model extracts the fields, with no templates or per-layout rules.

Validation

Data is validated and enriched against Zucchetti master data, with anomalies flagged for review.

Write to Zucchetti

The record is written into Zucchetti via REST API, webhooks or SQL, ready to be posted.

Benefits

What changes with Data Alchemy's Zucchetti integration

Zero data entry

Data enters Zucchetti with no manual typing: the finance team moves from copying to reviewing exceptions.

Master-data consistency

Validation against Zucchetti master data reduces coding errors, wrong vendors and items not found.

Faster closing times

Payables reach Zucchetti in seconds, speeding up posting, control and payment.

No new software for users

Users keep working in Zucchetti: the automation operates behind the scenes on document acquisition.

Full traceability

Every document keeps the link to the Zucchetti record it created, for audit and reconciliation.

Scales to all documents

From invoice to delivery note to order: the same Zucchetti integration covers every document flow.

Go deeper

Other integrations and resources

ERP integration

SAP

Extracted data written directly into SAP via REST API, webhooks and SQL.

Learn more →ERP integration

TeamSystem

Native TeamSystem integration, data validated on master data.

Learn more →API

Developer API

REST API, webhooks and SQL to integrate IDP into your stack, including Zucchetti.

Learn more →

FAQ

Frequently asked questions about Zucchetti integration

Yes. Data extracted from documents is written into Zucchetti via REST API, webhooks or SQL queries, mapped to invoice, order and delivery-note fields, after validation against Zucchetti master data.

The integration feeds Zucchetti's accounts-payable and management flows via REST API, webhooks or SQL writes, adapting to your environment's configuration.

Accounts-payable invoices, delivery notes, orders, contracts and price lists. The same Intelligent Document Processing flow extracts the data and writes it into Zucchetti, regardless of document type.

Before writing, data is matched against Zucchetti master data — vendors, item codes, open orders. Anomalies are flagged for review, so only consistent data is entered.

Extraction and validation take about 3 seconds per document; the write to Zucchetti happens immediately after, in real time via API or webhook.

Requests to Data Alchemy use a Bearer API key in the Authorization header over HTTPS, with no OAuth flow to implement. Outgoing webhooks are signed with HMAC SHA-256 in the X-Data-Alchemy-Signature header: verify the signature before writing the record into the ERP.

POST /v1/documents to submit the document with erp_target=zucchetti, GET /v1/documents/{id} to retrieve the structured JSON, and POST /v1/webhooks to register the endpoint receiving the document.processed event. Base URL: https://api.data-alchemy.ai/v1.

Yes: past the threshold the API responds 429 with error.code rate_limit_exceeded. The recommended handling is a retry with exponential backoff; undelivered webhooks are retried automatically anyway, so no document headed for Zucchetti is lost.

No. Data Alchemy handles authentication, field mapping and error handling towards the ERP: during onboarding the technical team defines endpoints, credentials and staging tables for your installation with you, cloud or on-premise.

Get your documents into Zucchetti, without data entry

Show us a sample of your documents: we'll demonstrate extraction, master-data validation and the write to Zucchetti on your real case.

Request a demo