Wraps each CSV record in UTF-8, entity-safe XML for integration engineers feeding SOAP buses, XSD gates, or partner portals that still reject “almost XML.”
ConversionTab emits XML in your browser—supplier extracts with pricing codes never cross a hosted transformer.
You stay in control of when text leaves the tab for validators or email.
Conversion focus
Schema-aware handling helps keep columns and nested fields understandable.
SOAP payloads, XSD gates, and partner validators still reject malformed XML on the first byte. Finance and ops grids have to become a root, repeating record tags, and names that match the published schema—not “almost XML.”
Encoding: UTF-8 bytes with a UTF-16 declaration, or BOM surprises. Broken tags: raw `<` / `&` in cells. Duplicate headers → duplicate element names. Wrong delimiter → shifted columns and nonsense tags. Ragged quoting → one giant field. Empty cells vs what your XSD allows for optional or `xsi:nil`.
Procurement CSV → repeating `<Line>` for an ERP SOAP import. Internal feed where the portal only ingests XML. Regulatory appendix rows → XSD-shaped elements for filing packages.
Integration engineers on buses, backend devs matching WSDLs, data engineers staging supplier drops, compliance packaging evidence trees—anyone where JSON-only SPAs are not the consumer.
Use NULL for empty field: prevents SQL errors when inserting missing values into nullable columns.
NOTE - you can change the column names below by overwriting the Field Name value.
Key: the first column is checked automatically. Confirm it matches your table’s primary key before generating UPDATE or DELETE (composite keys: check every key column).
| # | Field Name | Data Type | Max Size | Key | Include | Trim | Use NULL for Empty Field |
|---|---|---|---|---|---|---|---|
| Paste CSV above to load columns. | |||||||
Map each vCard field to a CSV column. Include is checked automatically when a column is mapped; uncheck to skip that field in the file, or set Mapping to — none — to clear it. Use Check all / Uncheck all under the mapping table for every row at once.
| # | VCF Field | Mapping | Include |
|---|---|---|---|
| Paste CSV above to load mapping options. | |||
Run after delimiter, header row, and skip/limit look right—preview appears in the output panel below.
A flat CSV grid is transformed into a predictable XML tree:
Once this structure is in place, XML becomes predictable for validators, APIs, and downstream systems.
Expose records in a grid for finance or ops review.
Hand off to APIs and mobile clients that prefer JSON.
Move partner XML into diff-friendly GitOps text.
Load tree-shaped feeds into staging tables after XSD pass.
Export to calendar apps when rows represent meetings or shifts.
Use when the web or a CMS needs a pasteable table fragment.
Use when APIs, fixtures, or mobile clients need structured objects.
Use when the next hop is INSERT-ready text for a database load.
Export to contacts apps when rows represent people, not events.
Use this when you need an XSD-diffable slice, a legacy SOAP list skeleton, or feed-shape evidence in PR—often with skip/limit first. For huge signed feeds with checksums and idempotent replay, plan streaming ETL instead of one browser pass. Lock early: attribute vs child placement for IDs (XPath and generated clients break if you flip later); one logical record per row and stable headers so declared element names stay predictable.
Serialize in your tab: iterate on tag names and options, then copy or save UTF-8 XML for `xmllint`, IDE schema plugins, or CI—without uploading the extract.
Flatten trees into rows when warehouses or Git workflows want delimiter text.
Unfold cards into TEL/EMAIL columns for dedupe before another import.
Materialize config lists into a grid ops can annotate before merge.
Freeze tables for legal, procurement, or print-room workflows.
Write repo-native YAML when GitOps—not Excel—is next.
Package typed workbooks when humans—not parsers—must sign off.
Typed sheets as JSON fixtures for automation and tests.
YAML config blocks compiled into runtime JSON.
Accordions follow integration order: overview → mapping → structure checks → common failures → XSD-facing FAQs.
Turn a CSV extract into hierarchical XML: one root, repeated row elements, headers as tag names, cell text entity-escaped—ready for XSD checks, SOAP-style payloads, and partner validators.
Namespaces, signatures, and multi-GB streaming stay in your integration tier once the shape is proven on a slice.
Headers → local tag names under each row record (or attributes if you map them). Fix illegal XML name characters in the sheet—spaces, slashes, leading digits—before export.
Rows → one repeated sibling element per line (typical XSD line-feed pattern). Empty cells emit empty elements; xsi:nil is a schema choice, not automatic here.
Quick pass: match “first row is column names”, delimiter, skip, and limit → convert → diff one <record> against headers → validate a small slice with your XSD or partner sample.
<data>
<record>…</record>
<record>…</record>
</data>maxOccurs and list consumers honest.< in cells — must serialize as entities; parse errors usually point at the cell first.SKU_123 as a tag means “first row is column names” is wrong.xsi:nil are schema rules; align empties with your XSD.Help
One question per row — expand only what you need.
When it is on, the first line becomes the source of element (or attribute) names—those strings must be valid XML names for predictable XSD mapping. Turn it off only if your file truly has no header row.
Use Skip to drop banner or metadata rows at the top of the export. Use Limit to convert only the first N data rows so you can run a fast validator pass before scaling to the full feed.
Open Choose input options and pick Tab, Bar, or the correct delimiter. If it is unusual, type a single character under Other. Wrong separators produce shifted columns and bogus tag content.
No tool can promise that without your schema: it produces well-formed UTF-8 XML with escaped text. You still match tag names, nesting, and namespaces to the XSD or WSDL your partner published.
They are escaped as entity references so the document stays well-formed. If you embed raw markup on purpose, treat the cell as opaque text—validators will still see literal characters, not nested XML.
Typically one root element wraps every row; each row becomes a repeated child element (for example <record>) with one child tag per column—good for SOAP-style lists and feed validators.
Options may expose attribute-style mappings for some workflows. Changing conventions after integrators depend on XPath breaks consumers—pick one model and keep exports stable.
Copy from the output or download a named .xml. Load sample fills a demo grid; Clear wipes input and output.
Escapes &, <, > so XML parsers never break mid-document.
Headers map 1:1 to tag names for stable XPath queries.
Single root ensures full document validity for validators.
UTF-8 safe output prevents encoding-related failures.
Each row = one repeated element—SOAP list / XSD repeat shape.
Skip/limit for a fast XSD or partner sample before full feed.