L’XML è ancora ovunque: feed editoriali, integrazioni legacy, export ERP/CRM, allegati email. Se lavori in marketing e automazione, saper leggere e trasformare XML in JSON è una super‑skill per connettere fonti “vecchie” con le tue API moderne. In questa guida pratica ti mostro come usare il nodo xml n8n per il parsing XML in n8n, convertire XML in JSON con n8n, generare XML da JSON in n8n (con alternative sicure), gestire attributi/namespace/CDATA e costruire workflow end‑to‑end (RSS → Google Sheets, XML allegato → API REST). Useremo configurazioni verificate, snippet di codice e best practice per evitare insidie come array incoerenti, payload enormi o errori di parsing. L’obiettivo: farti costruire pipeline affidabili che mappano i campi XML verso API/DB in pochi passi, con una base solida per scalare in produzione.

[IMG: schema alto livello “Sorgenti XML → XML to JSON Converter → Normalizzazione/Mapping → Destinazioni”]

Cos’è il nodo XML di n8n e quando usarlo

Il nodo XML di n8n è pensato per trasformare documenti XML in oggetti JSON operativi nel flusso, facilitando la successiva mappatura verso API, fogli o database. Nella documentazione tecnica è descritto come un “XML to JSON Converter”, ovvero un convertitore dedicato che prende in input testo XML e produce JSON. Perché usarlo:

• parsing XML in n8n per unire fonti legacy con tool moderni
• normalizzare feed RSS/Atom con n8n e scriverli in Google Sheets
• mappatura campi XML verso API/DB, compresa la trasformazione XML per API REST interne
• gestione allegati XML da email o file system

Limiti e considerazioni:

• L’operazione confermata è la conversione XML → JSON con parametri specifici del convertitore (vedi sezione successiva). La conversione JSON → XML non è documentata come operazione nativa nello stesso convertitore: più avanti ti mostro alternative robuste per generare XML da JSON in n8n senza introdurre rischi.
• Gli XML reali contengono attributi, namespace, CDATA; la qualità dell’output JSON dipende dal documento. In molti casi è utile una fase di “post‑normalizzazione” con un nodo Code per ottenere array coerenti e una struttura prevedibile.
• Con file XML molto grandi, pianifica difese: filtri a monte, chunking dove possibile, e controlli sui timeout per evitare rallentamenti o “out of memory”.

[IMG: mappa decisionale “Quando usare il convertitore XML→JSON vs quando ricorrere a normalizzazione/Code/servizi esterni”]

Preparare l’input ed evitare insidie nel payload

Prima di convertire, devi portare l’XML dentro il workflow come testo pulito. Le tre vie più comuni:

• HTTP: scarica il feed o il file da un endpoint. Verifica encoding e content type; salva il corpo come stringa nell’item (per esempio in una proprietà json.xmlData) da passare al convertitore.
• File locale/cloud: leggi un file XML con un nodo di lettura (locale o storage) e, se lo ottieni in binario, aggiungi un passaggio di conversione a testo prima della trasformazione.
• Email: molti ERP inviano XML come allegati. Estrai l’allegato, converti a testo e inseriscilo in una proprietà JSON (es. xmlData) pronta per il nodo XML.

Consigli pratici per l’ingestione:

• Valida che il contenuto inizi con < e sia un XML ben formato; se possibile, scarta subito file troppo grandi o non conformi (error handling nel parsing XML).
• Uniforma l’encoding a UTF‑8 ed evita caratteri “invisibili” (BOM o whitespace anomali) che possono causare errori.
• Aggiungi metadati utili (fonte, timestamp, ID file) al JSON per avere tracciabilità in logging e audit.

[IMG: esempio di workflow “HTTP Request → (converti a testo) → setta $json.xmlData → XML to JSON Converter”]

Conversione XML → JSON: configurazione e normalizzazione dell’output

Il percorso più rapido e affidabile per convertire XML in JSON in n8n usa il convertitore dedicato. Configurazione verificata:

• Node: XML to JSON Converter
• Parametri essenziali:
• operation: “convert”
• source: “xml”
• target: “json”
• data: “{{ $json.xmlData }}”

Esempio di configurazione (campo dati in espressione):

operation: "convert"
source: "xml"
target: "json"
data: "{{ $json.xmlData }}"

Dopo la conversione, ottieni un oggetto JSON che rispecchia la struttura del tuo XML. Per casi reali è spesso utile una fase di “post‑normalizzazione” per stabilizzare lo schema:

• normalizzazione di array XML: se un nodo può comparire 1..n volte, converti sempre a array. Questo evita branching complesso a valle.
• gestione attributi e namespace XML: decidi una convenzione (per esempio spostare gli attributi in un oggetto _attr e rimuovere i prefissi di namespace) per semplificare mapping e analisi.
• trattamento CDATA in XML: tratta il contenuto CDATA come testo e normalizzalo in una proprietà esplicita (es. _text).

Snippet (Code) per array coerenti e attributi dedicati:

// Utility: garantisce array per i campi passati
const ensureArray = (val) => Array.isArray(val) ? val : (val == null ? [] : [val]);

// Esempio di normalizzazione su una sezione specifica
const doc = $json; // output del convertitore
// Esempio: doc.feed.entry potrebbe essere singolo oggetto o array
doc.feed = doc.feed || {};
doc.feed.entry = ensureArray(doc.feed.entry);

// Spostamento attributi (se nel tuo JSON gli attributi sono in una proprietà "@")
const normalizeAttrs = (obj) => {
  if (obj && typeof obj === 'object') {
    if (obj['@']) {
      obj._attr = obj['@'];
      delete obj['@'];
    }
    for (const k of Object.keys(obj)) normalizeAttrs(obj[k]);
  }
};
normalizeAttrs(doc);

return [{ json: doc }];

Questo approccio rende prevedibile l’output per la mappatura verso API/DB, riducendo i rami condizionali nei nodi successivi.

[IMG: confronto prima/dopo la normalizzazione: attributi in _attr e array coerenti]

Attributi, namespace e array coerenti nel risultato

Gli XML “di produzione” portano tre sfide principali:

• Attributi: spesso contengono metadati importanti (es. id, type). Se il convertitore li espone con un prefisso o in una chiave speciale, convertili in un oggetto dedicato (es. _attr) e mantieni i valori tipizzati (stringhe o numeri coerenti).
• Namespace: i prefissi (es. atom:, media:, xsi:) complicano la vita al mapping. Nella normalizzazione puoi rimuovere i prefissi nel nome chiave e conservare l’informazione in un campo opzionale (es. _ns) se ti serve a valle.
• Array coerenti: elementi opzionali che diventano array solo quando compaiono più volte sono una causa comune di errori. Uniformali sempre ad array con una utility come ensureArray.

Esempio di post‑process per namespace e testo:

const doc = $json;

// Rimuovi prefissi "ns:" dalle chiavi
const stripNs = (obj) => {
  if (Array.isArray(obj)) return obj.map(stripNs);
  if (obj && typeof obj === 'object') {
    const out = {};
    for (const [k,v] of Object.entries(obj)) {
      const nk = k.includes(':') ? k.split(':').pop() : k;
      out[nk] = stripNs(v);
    }
    return out;
  }
  return obj;
};

return [{ json: stripNs(doc) }];

Queste normalizzazioni ti permettono di costruire mapping stabili verso Google Sheets, DB o API REST, riducendo sorprese quando il feed cambia lievemente.

[IMG: tabella con esempi di chiavi prima/dopo il remove namespace]

Conversione JSON → XML: generazione documento e mappatura campi

Se devi generare XML da JSON in n8n (es. invio a un partner legacy), procedi con due strategie sicure:

• Generazione via Code (JS) controllata: costruisci stringhe XML con escape sicuro, per payload semplici/medi. È altamente prevedibile e “sotto controllo”.
• Servizio esterno di conversione: se devi rispettare XSD complesse, valuta un microservizio o un’API che parta da JSON e applichi uno schema.

Esempio (Code) per costruire un XML semplice:

// Input: $json.order = { id, customer: { name, email }, items: [{sku, qty}] }
const esc = (s) => String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
const o = $json.order;
let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
xml += `<order id="${esc(o.id)}">`;
xml += `<customer><name>${esc(o.customer.name)}</name><email>${esc(o.customer.email)}</email></customer>`;
xml += `<items>`;
for (const it of (o.items || [])) {
  xml += `<item><sku>${esc(it.sku)}</sku><qty>${esc(it.qty)}</qty></item>`;
}
xml += `</items>`;
xml += `</order>`;
return [{ json: { xml } }];

Note:

• Mantieni i tipi e la formattazione coerenti con i requisiti del destinatario.
• Per validazione XML tramite XSD (servizi esterni), invia l’XML generato a un endpoint che esegue lo schema check e restituisce errori leggibili prima dell’invio finale.
• Se ti serve performance/complessità maggiori (namespace, attributi diffusi), considera una libreria dedicata in un microservizio esterno.

[IMG: blocco “Code” che produce xml e nodo successivo che lo invia via HTTP]

Esempi rapidi di workflow end‑to‑end

Feed RSS/Atom → JSON → Google Sheets

Obiettivo: estrarre titoli, link, date da un feed e salvarli in un foglio.

• HTTP Request: scarica il feed (body testuale).
• Set: metti il contenuto in $json.xmlData.
• XML to JSON Converter:
• operation: “convert”
• source: “xml”
• target: “json”
• data: “{{ $json.xmlData }}”
• Code: normalizza array (entry/item), rimuovi namespace, estrai campi chiave.
• Google Sheets (Append): mappa title, link, published.

Tip:

• Deduplica: conserva gli ID già importati (in Sheets o in uno stato esterno) per evitare doppie righe.

[IMG: workflow canvas con 5 nodi in sequenza e mapping campi]

XML allegato email → parsing → chiamata API REST

• Ingest allegato: estrai l’XML e convertilo a testo in $json.xmlData.
• XML to JSON Converter: conversione come sopra.
• Code: mappa i campi richiesti dall’API di destinazione (ad es. { orderId, amount, items[] }).
• HTTP Request (POST): invia il JSON all’endpoint REST.
• Logging: registra esito e payload chiave in un log centralizzato (Sheet/DB).

[IMG: flusso con ramo errori che invia alert Slack se il parsing fallisce]

Best practice, errori comuni e performance in produzione

• Error handling nel parsing XML:
• Valida la presenza del root node atteso e gestisci eccezioni con rami “on fail”.
• Aggiungi test rapidi (regex/startsWith) per scartare payload non XML.
• Ottimizzazione performance con file XML grandi:
• Filtra a monte dove possibile (parametri lato server, range date).
• Evita di mantenere in memoria documenti enormi; se prevedi XML giganti, valuta pipeline a chunk o servizi esterni di pre‑processing.
• Imposta timeout e retry sensati in HTTP Request; logga tempi e dimensione file.
• gestione attributi e namespace XML:
• Adotta una convenzione unica (_attr per attributi, rimozione prefissi) e applicala in un solo punto (un Code subito dopo la conversione).
• trattamento CDATA in XML:
• Consideralo testo; se necessario, mappalo in un campo esplicito (_text) e ripulisci markup indesiderato.
• unione dati XML e sorgenti JSON in n8n:
• Usa Merge per combinare dataset provenienti da feed XML con arricchimenti JSON (es. tabelle di lookup).
• Sicurezza e compliance:
• Sanifica e logga solo i campi necessari; attenzione a PII in feed di terze parti.
• Versiona i mapping: se cambia la struttura del feed, alza una “version key” e adatta la normalizzazione.

Insight operativo: centralizza la normalizzazione (array, attributi, namespace) in un unico nodo Code subito dopo la conversione. Così ogni workflow che consuma XML avrà lo stesso “contratto” JSON, riducendo bug e costi di manutenzione.

[IMG: checklist di produzione con validazioni, timeout, normalizzazione e logging]

Quick Takeaways

• Usa il “XML to JSON Converter” con operation “convert”, source “xml”, target “json” e data che punta al testo XML.
• Normalizza subito array, attributi e namespace per avere un JSON stabile da mappare.
• Per JSON → XML, genera via Code o servizi esterni e valida contro XSD quando richiesto.
• Con feed RSS/Atom, deduplica gli ID e registra gli esiti in un log centralizzato.
• Su XML grandi: filtra a monte, imposta timeout e monitora latenza/dimensioni.
• Mantieni una convenzione unica per attributi (_attr) e rimozione dei namespace.

Conclusione

Portare l’XML nel tuo stack moderno è semplice se separi bene i compiti: ingest pulita, conversione con il nodo XML di n8n, normalizzazione coerente e mapping verso le tue destinazioni. Con l’“XML to JSON Converter” imposti in pochi secondi operation “convert”, source “xml”, target “json” e lavori subito con JSON leggibile. Una volta stabilite regole chiare per attributi, namespace, CDATA e array, costruisci pipeline riciclabili per feed editoriali, allegati email e integrazioni legacy. Quando serve l’uscita inversa (JSON → XML), usa un Code node o un servizio esterno e valida contro XSD per garantire compatibilità. Se sei un marketer che vuole aumentare produttività e qualità dati, inizia da un caso reale (RSS → Google Sheets) e poi scala: aggiungi deduplica, logging, alert sugli errori e test automatici sui mapping. In poche ore avrai un flusso stabile che trasforma l’XML da ostacolo a risorsa, pronto per alimentare le tue analisi, le tue campagne e le tue automazioni.

FAQ

• Cos’è il nodo XML di n8n e cosa fa in pratica?

• È un convertitore che trasforma testo XML in JSON operativo nel workflow. Lo usi per parsing XML in n8n e per convertire XML in JSON con n8n, utile per mappare i dati verso API/DB o Sheets.

• Come gestisco attributi e namespace dopo la conversione?

• Subito dopo l’XML → JSON, applica una normalizzazione in un Code node: sposta gli attributi in _attr e rimuovi i prefissi di namespace dalle chiavi. Così semplifichi la mappatura e riduci gli errori.

• Posso generare XML a partire da JSON?

• Sì, con un Code node che costruisce l’XML in modo controllato (escape sicuro) o tramite un servizio esterno dedicato. Per casi complessi, valuta validazione XML tramite XSD (servizi esterni) prima dell’invio.

• Come evito problemi con array “a volte singoli, a volte multipli”?

• Applica una utility ensureArray ai nodi che possono ripetersi. La normalizzazione di array XML garantisce coerenza e riduce if/else a valle.

• Ho XML molto grandi: come ottimizzare?

• Filtra a monte, imposta timeout e monitora dimensioni e latenza. Evita di tenere tutto in memoria; se necessario, usa pre‑processing esterni o spezza il processo in step più piccoli.

Hai suggerimenti o un caso XML “ostico” da risolvere? Raccontamelo: quale feed o integrazione vuoi automatizzare per primo? Se la guida ti è stata utile, condividila con il tuo team per accelerare le prossime automazioni.