# Il livello documentale tra il vostro ERP e i vostri strumenti

Source: https://arhivix.com/it/developers

Ultima revisione: 15 novembre 2026. Dati verificati sulla versione dell'app rilasciata in quella data.

Arhivix è un sistema di gestione documentale con REST API v1, webhook firmati e un server MCP, sviluppato da NOTIX DOO a Belgrado. Riceve i documenti, li legge con OCR e AI, fa confermare a una persona i valori che contrassegnate per la verifica e passa i dati al vostro ERP e ai vostri strumenti.

È ospitato su AWS nell'UE (Francoforte e Dublino). Un nuovo processo aziendale si configura nell'app come tipi di documento, flussi e registri, quindi il codice da scrivere resta minimo: un servizio ricevente accanto al vostro ERP.

## Il ruolo di Arhivix quando i dati arrivano nei documenti

Fatture dei fornitori, bolle di consegna, ordini d'acquisto, certificati e contratti arrivano come PDF e scansioni, mentre l'ERP si aspetta record puliti. Arhivix gestisce il lato documentale di questa integrazione, in sei passaggi.

1. **I documenti arrivano.** Tramite caricamento, dalle caselle email aziendali via Gmail, Microsoft 365 o IMAP, da uno scanner desktop, dalla fotocamera del telefono o dal vostro programma tramite l'API. Arhivix acquisisce documenti anche da OneDrive, SharePoint, Google Drive, da un bucket Amazon S3 o da un container Azure Blob.
2. **Arhivix li legge.** L'OCR trasforma le scansioni in testo. Un modello linguistico riconosce il tipo di documento e propone i campi: fornitore, acquirente, codici fiscali, importi, IVA, date e numeri di una fattura, oppure parti, date, termine di preavviso, valore e condizioni di pagamento di un contratto.
3. **Una persona conferma.** Un valore letto resta una proposta finché la sua regola di verifica non è soddisfatta. Per ogni campo di un tipo di documento scegliete la regola: Automatica, Da verificare o Conferma obbligatoria. I revisori confrontano i valori con l'originale e li confermano campo per campo.
4. **La pratica avanza.** Un flusso verifica le condizioni, invia il documento in approvazione a una persona o a un ruolo, lo archivia, lo aggiunge a un fascicolo aziendale e ne monitora la scadenza.
5. **Il vostro codice riceve una notifica.** Un passaggio del flusso invia un messaggio firmato al vostro servizio ricevente, che legge il record tramite la REST API. Caricamenti, nuovi documenti, fatture ed email arrivano anche come eventi webhook firmati e nel feed delle modifiche.
6. **L'ERP resta il sistema di riferimento.** Il vostro servizio ricevente scrive nell'ERP tramite l'importazione che l'ERP supporta. Quando un flusso ha bisogno della prova che l'ERP ha acquisito il record, richiede una conferma esterna e attende la vostra callback firmata.

**L'integrazione in uno schema**

1. **Il vostro ERP**
   - ERP legacy, software di contabilità o gestionale di settore
   - Resta il sistema di riferimento
   - → Il vostro servizio ricevente: L'importazione supportata dal vostro ERP
2. **Il vostro servizio ricevente**
   - Verifica la firma
   - Legge il record tramite l'API
   - Scrive tramite l'importazione supportata dal vostro ERP
   - → Arhivix: Webhook firmati e REST API
3. **Arhivix**
   - Acquisizione
   - Lettura con OCR e AI
   - Conferma da parte di una persona
   - Flussi e approvazioni
   - Fascicoli aziendali
   - Archiviazione, versioni e log di audit
   - → Strumenti e assistenti: Webhook, REST API e MCP
4. **Strumenti e assistenti**
   - Notifiche in Microsoft Teams
   - Zapier, Make, n8n e Power Automate tramite i loro passaggi webhook e HTTP
   - Claude, Claude Code e Codex tramite MCP

## Collegare un ERP legacy privo di API

L'ERP resta com'è. I documenti continuano ad arrivare come oggi, e sul lato ERP dell'integrazione ci sono il vostro servizio ricevente e l'importazione che il vostro ERP supporta già.

- Email e scansioni: i fornitori continuano a inviare PDF, e Arhivix li legge dalla casella email, dallo scanner o dal telefono.
- Un piccolo servizio ricevente, il vostro middleware accanto all'ERP: accetta i webhook firmati o interroga periodicamente `GET /events`, legge il record tramite l'API e lo scrive con l'importazione offerta dall'ERP stesso, ad esempio una cartella di scambio file, una tabella di staging o l'SDK del fornitore.
- SAP Business One: lo collegate dalle Impostazioni tramite SAP Service Layer, e ogni 15 minuti Arhivix ne legge partner commerciali, articoli, magazzini, ordini d'acquisto, entrate merci e fatture.
- Strumenti con un trigger webhook e un passaggio HTTP, come Zapier, Make, n8n e Power Automate: ricevono l'evento e leggono il record tramite l'API.
- Microsoft Teams: un canale riceve un messaggio quando una fattura viene creata, approvata o rifiutata, quando l'approvazione di una fattura viene richiesta o completata e quando viene creata un'eccezione.
- La direzione opposta: un flusso invia un messaggio firmato al vostro sistema e può attenderne la conferma firmata prima di proseguire.
- Fatture elettroniche via Peppol: tramite l'account della vostra azienda presso Storecove, un access point Peppol, Arhivix invia le fatture che emettete (BIS Billing 3.0) e riceve le fatture dei fornitori.

L'ERP resta il sistema di riferimento. Arhivix legge, controlla e instrada i documenti, e il vostro codice inoltra i risultati.

## Cosa ottenete invece di costruire una pipeline documentale

Chiamare un modello linguistico su un PDF è la parte più piccola. Un'integrazione con un ERP richiede anche l'acquisizione, la conferma da parte di una persona (human in the loop), le approvazioni, un luogo per l'originale e una traccia di audit di ogni decisione. Queste parti funzionano oggi in Arhivix.

**Le parti dell'integrazione e dove si trovano in Arhivix**

| Parte dell'integrazione | Cosa fa Arhivix | Dove si collega il vostro codice |
| --- | --- | --- |
| Acquisizione | Caricamento, caselle email aziendali, scanner, fotocamera del telefono e fonti collegate come OneDrive, SharePoint, Google Drive, Amazon S3 e Azure Blob. | `POST /nodes/{id}/upload`: multipart, fino a 200 MiB. |
| Lettura | OCR, campi proposti e 22 tipi di documento riconosciuti. | `GET /nodes/{id}/metadata` restituisce `ocr_status`, la classificazione con `doc_type`, un riepilogo e i tag, e i dettagli estratti della fattura. |
| Conferma | Smart Inbox mostra un percorso suggerito e il grado di confidenza dell'AI, e una persona approva o rifiuta. I valori letti vengono confermati campo per campo secondo la regola di verifica impostata. | I valori del registro hanno uno stato, ad esempio `confirmed` o `proposed`, e la condizione di flusso «È confermato» (Is confirmed) protegge i passaggi del suo ramo positivo. |
| Approvazioni | Catene fino a cinque persone o ruoli, in sequenza, con una scadenza ed escalation a un ruolo. Chi ha avviato l'elaborazione e chi ha già approvato sono esclusi dalle fasi successive. | All'interno di Arhivix, nella coda Approvazioni aziendali. Dopo la decisione il flusso prosegue da solo. |
| Pratica | Fascicoli aziendali con una checklist dei documenti richiesti, soggetti monitorati, documenti attesi e registri. | `POST /document-pipelines/registers/{id}/query` restituisce le righe di un registro. Anche i documenti dei soggetti monitorati sono leggibili tramite l'API. |
| Archiviazione e traccia di audit | Versioni, permessi per spazio di lavoro e per cartella, e un log di audit che registra le azioni via API con la chiave che le ha eseguite. | `GET /nodes/{id}/versions` e `GET /nodes/{id}/download`. |

> I vostri tipi di documento possono usare 22 tipi di valore, tra cui Tabella, Elenco, Record collegato e Valore calcolato.

## Come si modella una pratica in Arhivix

Ogni processo aziendale è fatto delle stesse parti: un soggetto con i suoi dati, delle evidenze, delle regole, uno stato e delle azioni consentite. In Arhivix questo è il fascicolo aziendale, un modello di case management le cui parti reggono processi molto diversi.

**Un modello, due processi**

| Parte della pratica | In Arhivix | Qualifica fornitori | Consegna del progetto |
| --- | --- | --- | --- |
| Soggetto | Un fascicolo con un tipo, una chiave aziendale, un periodo, un responsabile e una scadenza. | Un fornitore. | Un progetto. |
| Evidenze | Documenti accettati in base a una checklist. Ognuno viene registrato con l'hash del contenuto e la data di validità. | Visura camerale, il certificato richiesto e l'assicurazione. | Documentazione as-built, manuali d'uso, garanzie e certificati, verbali di ispezione e collaudo. |
| Collegamenti | Campi di tipo Record collegato, registri e soggetti monitorati: un partner, un'apparecchiatura, un immobile o un tipo definito da voi. | Il partner e i suoi certificati. | L'immobile e le sue apparecchiature. |
| Regole | Voci obbligatorie con un numero minimo e un controllo della scadenza, una regola di verifica per campo e condizioni di flusso con 18 operatori. | Il certificato e l'assicurazione devono essere validi. | Ogni gruppo richiede almeno un documento. |
| Stato | In raccolta, In attesa di verifica, Pronto per il pacchetto finale, Archiviato. | Gli stessi quattro stati. | Gli stessi quattro stati. |
| Azioni | Richiedere i documenti mancanti tramite un link di caricamento sicuro, accettare o rifiutare ogni documento, confermare la raccolta, inviare in approvazione, notificare, inviare dati a un altro sistema. | Chiedere al fornitore un certificato rinnovato. | Chiedere all'appaltatore i manuali mancanti. |
| Risultato | Una raccolta confermata, uno storico delle decisioni con azione, motivo e persona, e un pacchetto ZIP finale. | Un fornitore qualificato, con le prove. | Un pacchetto di consegna. |

> Entrambi gli esempi sono modelli pronti nell'app, insieme a Documenti mensili del cliente (fatture di vendita, fatture di acquisto ed estratti conto).

## Perché il processo successivo è configurazione, non un nuovo progetto

Tra il primo processo e il secondo il motore resta lo stesso. Cambiano le definizioni: tipi di documento, flussi e registri, e il modello di fascicolo che il processo segue. Il vostro team le imposta nell'app, in Elaborazione documenti, e il vostro servizio ricevente continua a funzionare.

1. **Scegliete il compito.** La procedura guidata di configurazione chiede cosa deve fare Arhivix: fatture in arrivo via email, contratti e scadenze, registri di assistenza o un vostro documento. Nulla viene attivato finché non confermate.
2. **Mostrate un esempio.** Descrivete il tipo di documento o trascinate dei documenti di esempio, e l'assistente dei tipi ne propone i campi. Esaminate la proposta prima che venga salvato qualcosa.
3. **Testate, poi pubblicate.** Un tipo viene testato su un documento con valori noti, e solo la versione testata viene pubblicata. Ogni versione resta nello storico.
4. **Disegnate il flusso.** L'editor dei flussi ha 24 tipi di passaggio: approvazione, condizioni, instradamento con più regole, archiviazione, etichette, fascicoli, notifiche, scadenze e promemoria, ricerche nei registri, percorsi paralleli, sottoflussi, invio di dati a un altro sistema e richiesta di una conferma esterna.
5. **Riutilizzate la configurazione.** I modelli aziendali salvano le definizioni di tipi, registri, viste e widget in un file JSON che importate ovunque serva la stessa configurazione. I tipi importati restano bozze finché non vengono verificati su un esempio.

### Cosa ricorda Arhivix

- Dove vanno i documenti di un fornitore: dopo che una persona ha archiviato per tre volte documenti con lo stesso codice fiscale del fornitore nello stesso gruppo d'archivio, i nuovi documenti di quel fornitore vengono archiviati lì automaticamente.
- Come si legge un tipo di documento: «Ricorda per questo tipo di documento» (Remember for this document type) salva dove si trova un campo o cosa significa in una nuova versione del tipo, usata una volta testata e pubblicata.
- Le parole dei vostri documenti: una nota per campo su dove trovarlo e cosa significa, e le espressioni memorizzate per le opzioni di scelta.
- Le regole impostate dalle vostre persone: regole di archiviazione per fornitore, tipo di documento o categoria, regole email e flussi.
- Ogni decisione: correzioni e decisioni restano nello storico, con la persona e il motivo.

Questa memoria appartiene alla vostra azienda ed è conservata come regole, mappature e versioni dei tipi. I dati dei clienti non vengono usati per addestrare modelli di AI, come stabilisce l'accordo sul trattamento dei dati.

## REST API v1: autenticazione, limiti, caricamenti ed errori

- **Percorso base:** `/v1/api/v1`, dove entrambe le parti `v1` fanno parte del percorso. Una sola API per tutte le regioni: l'azienda viene ricavata dalla chiave.
- **Autenticazione:** `Authorization: Bearer <key>` oppure `X-API-Key: <key>`. Le chiavi iniziano con `ak_live_`.
- **Chiavi:** Le crea un Amministratore o il ruolo predefinito Sviluppatore in Impostazioni, Developer API. Una chiave ha un nome, permessi per area, un limite di richieste, una data di scadenza facoltativa e una allowlist di IP facoltativa, e viene mostrata una sola volta.
- **Modello di accesso:** Una chiave è un'identità di servizio a sé. I permessi limitano le operazioni, i ruoli aziendali decidono a quali risorse accede la chiave, e una nuova chiave parte senza accesso ad alcuna risorsa finché una persona non la verifica.
- **Limite di richieste:** Per chiave, da 10 a 10.000 richieste al minuto, 1.000 per impostazione predefinita. Le risposte includono `X-RateLimit-Limit`, `X-RateLimit-Remaining` e `X-RateLimit-Reset`.
- **Scritture:** Ogni scrittura include un header `Idempotency-Key`. Un risultato completato viene restituito di nuovo per sette giorni, quindi ripetere la richiesta è sicuro.
- **Caricamenti:** `multipart/form-data`, fino a 200 MiB, con l'header `X-Arhivix-Request-SHA256`: lo SHA-256 del corpo esatto della richiesta. Un caricamento mette in coda l'OCR automaticamente.
- **Risultati:** `GET /nodes/{id}/metadata` restituisce `ocr_status`, la classificazione con `doc_type`, la categoria, un riepilogo e i tag, e i dettagli estratti della fattura. `GET /nodes/{id}/text` restituisce il testo OCR pagina per pagina.
- **Registri:** `POST /document-pipelines/registers/{id}/query` restituisce i valori letti per i vostri tipi di documento. Ogni valore ha uno stato, ad esempio `confirmed` o `proposed`, e un filtro può richiedere un solo stato.
- **Elenchi:** Paginazione keyset: `limit` da 1 a 100 e il cursore da `meta.pagination.next_cursor`.
- **Feed delle modifiche:** `GET /events` restituisce gli eventi dal più vecchio, dallo stesso log che alimenta i webhook.
- **Ricerca:** `GET /search`, con filtri per tipo di documento, categoria e spazio di lavoro.
- **Errori:** Un'unica struttura per ogni errore: `error`, `message` e `meta.request_id`. Inviate `X-Request-ID` per far corrispondere i vostri log ai nostri.
- **Documentazione di riferimento:** Una descrizione OpenAPI 3.1, i JSON Schema degli eventi webhook ed esempi di client in Go e JavaScript. Li inviamo su richiesta.

Caricate una scansione e leggete cosa ha proposto Arhivix. `BASE_URL` termina con `/v1/api/v1`.

```bash
# Upload a document into a folder. The digest covers the exact multipart body.
boundary="bridge-example-boundary"
body="$(mktemp)"
{
  printf -- '--%s\r\nContent-Disposition: form-data; name="file"; filename="invoice.pdf"\r\nContent-Type: application/octet-stream\r\n\r\n' "$boundary"
  cat invoice.pdf
  printf '\r\n--%s--\r\n' "$boundary"
} > "$body"

curl --fail-with-body -sS \
  -H "Authorization: Bearer $API_KEY" \
  -H "Idempotency-Key: invoice-4471-upload" \
  -H "X-Arhivix-Request-SHA256: $(sha256sum "$body" | awk '{print $1}')" \
  -H "Content-Type: multipart/form-data; boundary=$boundary" \
  --data-binary "@$body" \
  "$BASE_URL/nodes/$FOLDER_ID/upload"

# OCR and reading start by themselves. Read the result with the id from the response:
curl --fail-with-body -sS \
  -H "Authorization: Bearer $API_KEY" \
  "$BASE_URL/nodes/$NODE_ID/metadata"
```

## Webhook firmati

Aggiungete l'indirizzo di un webhook nell'app, in Impostazioni, Developer API, Webhook: un indirizzo HTTPS pubblico, con tutti gli eventi o solo quelli che selezionate. Il segreto di firma viene mostrato una sola volta. Per notificare al vostro sistema solo i dati confermati, inserite in un flusso il passaggio «Invia dati a un altro sistema» (Send data to another system) dopo la condizione «È confermato».

- **Eventi:** `document.created`, `file.uploaded`, `email.received`, `invoice.created`, `invoice.updated`, `invoice.deleted`, `invoice.approved`, `invoice.rejected`, `invoice.storno`, `approval.requested`, `approval.completed`, `exception.created`, `exception.resolved`, `despatch_advice.created`, `despatch_advice.received`.
- **Da un flusso:** Il passaggio «Invia dati a un altro sistema» invia un messaggio firmato con il link al documento alla destinazione configurata. «Richiedi conferma esterna» (Request external confirmation) attende una callback firmata dal vostro sistema.
- **Payload:** Volutamente ridotto: l'id dell'evento, il nome dell'evento, l'ora, l'azienda e id, tipo e nome del record. Il servizio ricevente legge il record tramite l'API.
- **Firma:** `X-Arhivix-Signature` contiene `sha256=` e l'HMAC-SHA256 di `X-Arhivix-Timestamp`, un punto e il corpo grezzo della richiesta, calcolato con il vostro segreto. Rifiutate un timestamp che si discosta di oltre 300 secondi.
- **Consegna:** Qualsiasi risposta 2xx vale come conferma. Una consegna non riuscita viene ritentata dopo 1 minuto, 5 minuti, 30 minuti, 2 ore, 8 ore, 24 ore e 36 ore: otto tentativi in circa 70 ore.
- **Duplicati:** La consegna è at least once. Deduplicate in base all'`id` dell'evento o a `X-Arhivix-Delivery`.
- **Log delle consegne:** Ogni consegna mostra i tentativi, il codice HTTP, il payload e l'ultima risposta del vostro endpoint, con Riprova e Reinvia. Potete inviare un evento di test con un clic.

Il corpo di un evento `file.uploaded`.

```json
{
  "id": "evt_653a9632df26297d6d685aebb8e553fc779785cb260ed6002c4bd0d2d2e1556d",
  "event": "file.uploaded",
  "schema_version": 1,
  "schema": "https://arhivix.com/schemas/webhooks/v1/file.uploaded.schema.json",
  "occurred_at": "2026-08-10T09:00:00Z",
  "timestamp": "2026-08-10T09:00:00Z",
  "company_id": "company_example",
  "data": {
    "id": "node_example",
    "event_id": "workflow_occurrence_example",
    "target_type": "node",
    "name": "receipt.pdf",
    "triggered_by": "user_example"
  }
}
```

Verifica della firma in Node.js. Verificate prima i byte grezzi, poi fate il parsing del JSON.

```javascript
import { createHmac, timingSafeEqual } from 'node:crypto';

// rawBody:   the request body as a Buffer, captured before JSON parsing
// timestamp: header X-Arhivix-Timestamp
// signature: header X-Arhivix-Signature
export function verifyWebhook({ rawBody, timestamp, signature, secret }) {
  const now = Math.floor(Date.now() / 1000);
  const match = /^sha256=([a-f0-9]{64})$/.exec(signature ?? '');
  if (!/^[0-9]+$/.test(timestamp ?? '') || Math.abs(now - Number(timestamp)) > 300 || !match) {
    return false;
  }
  const expected = createHmac('sha256', secret)
    .update(timestamp, 'utf8')
    .update('.', 'utf8')
    .update(rawBody)
    .digest();
  const supplied = Buffer.from(match[1], 'hex');
  return supplied.length === expected.length && timingSafeEqual(supplied, expected);
}
```

## MCP: assistenti e agenti sui documenti della vostra azienda

Arhivix gestisce un server MCP ospitato all'indirizzo `https://mcp.arhivix.com/mcp`. Aggiungete l'indirizzo al vostro client, accedete ad Arhivix nel browser e autorizzate l'accesso per un'azienda. Non c'è alcuna chiave API da copiare.

- **Client:** Claude come connettore personalizzato, Claude Code e Codex, con comandi pronti nell'app.
- **Accesso:** OAuth con PKCE e registrazione dinamica dei client.
- **Chi autorizza:** Un Amministratore o una persona con il ruolo Sviluppatore, per un'azienda.
- **Lettura:** Ricerca e lettura sono sempre incluse: documenti, metadati, fatture, articoli, partner, automazioni e utenti consentiti dal ruolo di chi ha autorizzato.
- **Modifiche:** «Consenti modifiche» (Allow changes) è facoltativo e copre drive, cartelle, caricamenti, articoli, partner, automazioni e bozze. Emissione e invio restano alle persone.
- **Controllo:** La connessione riceve una propria chiave, con accesso limitato, un proprio limite di richieste e una data di scadenza. Compare in Impostazioni, Developer API, Chiavi API, dove potete revocarla immediatamente.

Lo stesso indirizzo funziona in ogni client.

```bash
# Claude Code
claude mcp add --transport http --scope user arhivix "https://mcp.arhivix.com/mcp"

# Codex
codex mcp add arhivix --url "https://mcp.arhivix.com/mcp"
codex mcp login arhivix
```

## Hosting, archiviazione e uso dei vostri dati

- **Hosting:** AWS nell'UE (Francoforte e Dublino).
- **Crittografia:** AES-256 a riposo e TLS in transito.
- **AI e i vostri dati:** I dati dei clienti non vengono usati per addestrare modelli di AI. Lo stabilisce l'accordo sul trattamento dei dati.
- **Il vostro bucket come fonte:** Arhivix legge i nuovi documenti dal vostro bucket Amazon S3, tramite un ruolo di sola lettura nel vostro account AWS, oppure dal vostro container Azure Blob.
- **Il vostro storage:** Enterprise supporta il bring your own storage: il bucket resta nel vostro account, con le vostre chiavi e sotto la vostra giurisdizione, mentre Arhivix continua a elaborare, indicizzare e servire i documenti tramite la stessa API.
- **Isolamento:** L'azienda viene ricavata dalla chiave, quindi una chiave accede ai dati di una sola azienda.
- **Traccia di audit:** Le azioni via API vengono scritte nel log di audit con l'identità di servizio e la chiave, e il log è esportabile.

Il quadro completo è nella pagina [Sicurezza](https://arhivix.com/it/security).

## Domande frequenti degli sviluppatori

### Posso inviare io i PDF a un modello linguistico invece di usare un livello documentale?

Potete, e la chiamata al modello è la parte più piccola. Prima che un valore possa arrivare a un ERP, qualcuno deve ricevere il documento, confermare ciò che è stato letto, approvarlo, conservare l'originale con le sue versioni e registrare chi ha deciso cosa. Arhivix si occupa di queste parti, così al vostro codice resta il lato ERP.

### Come evito che un valore non confermato arrivi nell'ERP?

Impostate la regola di verifica del campo su Conferma obbligatoria e inserite la condizione «È confermato» prima del passaggio che invia dati a un altro sistema, così solo il ramo confermato notifica il vostro servizio ricevente. Il servizio ricevente legge poi i valori da un registro, dove ogni valore ha il suo stato, ad esempio `confirmed`.

### Quali documenti legge Arhivix?

Riconosce 22 tipi di documento, tra cui fatture, contratti, bolle di consegna, note di credito, estratti conto, certificati, garanzie e offerte. Per qualsiasi altro documento, come un ordine d'acquisto o un registro di assistenza, definite un vostro tipo e ne scegliete i campi.

### Arhivix impara dalle correzioni, e un modello viene addestrato sui miei documenti?

Ricorda ciò che le vostre persone confermano: dove vanno i documenti di un fornitore, dove si trova un campo in un tipo di documento, quali parole indicano quale opzione. Questa memoria è conservata come regole e versioni dei tipi della vostra azienda. I dati dei clienti non vengono usati per addestrare modelli di AI, come stabilisce l'accordo sul trattamento dei dati.

### Cosa succede se il mio servizio ricevente non è raggiungibile?

Arhivix ritenta una consegna non riuscita dopo 1 minuto, 5 minuti, 30 minuti, 2 ore, 8 ore, 24 ore e 36 ore: otto tentativi in circa 70 ore. Il log delle consegne conserva ogni tentativo, con Riprova e Reinvia, e il feed delle modifiche `GET /events` permette al vostro codice di recuperare gli eventi persi.

### Come evito di elaborare due volte lo stesso evento?

La consegna è at least once, quindi deduplicate in base all'`id` dell'evento o a `X-Arhivix-Delivery`. Le scritture verso l'API includono un `Idempotency-Key`, e un risultato completato viene restituito di nuovo per sette giorni.

### Gli agenti AI possono lavorare con i nostri documenti?

Sì. Il server MCP ospitato all'indirizzo `https://mcp.arhivix.com/mcp` collega Claude, Claude Code e Codex dopo un accesso nel browser. La lettura segue il ruolo della persona che ha autorizzato la connessione. Le modifiche sono facoltative e si fermano prima dell'emissione e dell'invio, che restano alle persone.

### Dove sono conservati i dati?

Su AWS nell'UE (Francoforte e Dublino), cifrati a riposo con AES-256. I clienti Enterprise possono conservare i documenti in un proprio bucket S3-compatibile, con le proprie chiavi.

### Come inizio?

Create un account con il piano gratuito e aggiungete alcuni documenti reali per vedere come li legge Arhivix. La REST API v1 e i webhook firmati sono inclusi in ogni piano a pagamento, e le chiavi si creano in Impostazioni, Developer API. Chiedeteci la documentazione OpenAPI quando create la vostra prima chiave.
