---
seo_title: API JSON in XML | Converti file JSON in XML | EnConvert
meta_desc: Converti JSON in XML con POST /v1/convert/json-to-xml. Gli oggetti diventano figli di <root>, gli array elementi <item>. Download diretto o URL presigned.
keywords: api json in xml, convertire json in xml api, json to xml api, api rest json in xml, convertitore json xml api, trasformare json in xml api, endpoint json in xml, caricare json convertire in xml
---

# API JSON in XML

Converti un file JSON in XML con una singola richiesta a `POST /v1/convert/json-to-xml`. Gli oggetti JSON diventano figli diretti di `<root>`, gli array vengono racchiusi in elementi `<root><item>` e i valori scalari in `<root><value>`. Per default la risposta è costituita dai byte XML grezzi; imposta `direct_download=false` per ricevere invece metadati JSON con un URL di download presigned.

---

## Endpoint

```
POST /v1/convert/json-to-xml
```

**Content-Type:** `multipart/form-data`

**Input accettato:** file `.json` (codificati in UTF-8)

**Formato di output:** `.xml` (`application/xml`)

---

## Autenticazione

Richiede una chiave API privata oppure un token JWT ottenuto da una chiave pubblica.

```
X-API-Key: sk_your_private_key
```

Oppure:

```
Authorization: Bearer <jwt_token>
```

---

## Parametri della richiesta

| Parametro | Tipo | Obbligatorio | Default | Descrizione |
|-----------|------|----------|---------|-------------|
| `file` | file | Sì | -- | Il file `.json` da convertire. Deve essere codificato in UTF-8. |
| `output_filename` | `string` | No | Nome del file di input | Nome file di output personalizzato. L'estensione `.xml` viene aggiunta automaticamente. |
| `direct_download` | `boolean` | No | `true` | Con `true`, restituisce i byte XML grezzi. Con `false`, restituisce metadati JSON con un URL di download presigned. |

---

## Regole di conversione

- Un **oggetto JSON** `{"name": "Alice", "age": 30}` diventa:
  ```xml
  <root>
    <name>Alice</name>
    <age>30</age>
  </root>
  ```

- Un **array JSON** `[{"id": 1}, {"id": 2}]` diventa:
  ```xml
  <root>
    <item>
      <id>1</id>
    </item>
    <item>
      <id>2</id>
    </item>
  </root>
  ```

- Un **valore scalare** `"hello"` diventa:
  ```xml
  <root>
    <value>hello</value>
  </root>
  ```

L'elemento radice è sempre `<root>`. L'output è formattato (pretty-printed) con indentazione a uno spazio.

---

## Risposta

### Download diretto (`direct_download=true`, default)

```
HTTP 200 OK
Content-Type: application/xml
Content-Disposition: inline; filename="data_20260405_123456789.xml"
```

Restituisce i byte XML grezzi.

### Risposta con metadati (`direct_download=false`)

```json
{
    "presigned_url": "https://spaces.example.com/...",
    "object_key": "env/files/{project_id}/json-to-xml/data_20260405_123456789.xml",
    "filename": "data_20260405_123456789.xml",
    "file_size": 1234,
    "conversion_time_seconds": 0.05
}
```

---

## Esempi di codice

### Python

```python
import requests

with open("data.json", "rb") as f:
    response = requests.post(
        "https://api.enconvert.com/v1/convert/json-to-xml",
        headers={"X-API-Key": "sk_your_private_key"},
        files={"file": ("data.json", f, "application/json")}
    )

with open("data.xml", "wb") as out:
    out.write(response.content)
```

### Node.js

```javascript
const form = new FormData();
form.append("file", fs.createReadStream("data.json"));

const response = await fetch("https://api.enconvert.com/v1/convert/json-to-xml", {
    method: "POST",
    headers: { "X-API-Key": "sk_your_private_key" },
    body: form
});

const xml = await response.text();
```

### PHP

```php
$ch = curl_init("https://api.enconvert.com/v1/convert/json-to-xml");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["X-API-Key: sk_your_private_key"],
    CURLOPT_POSTFIELDS => ["file" => new CURLFile("data.json", "application/json")]
]);
$xml = curl_exec($ch);
curl_close($ch);
file_put_contents("data.xml", $xml);
```

### Go

```go
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, _ := writer.CreateFormFile("file", "data.json")
file, _ := os.Open("data.json")
io.Copy(part, file)
writer.Close()

req, _ := http.NewRequest("POST", "https://api.enconvert.com/v1/convert/json-to-xml", body)
req.Header.Set("Content-Type", writer.FormDataContentType())
req.Header.Set("X-API-Key", "sk_your_private_key")
resp, _ := http.DefaultClient.Do(req)
```

---

## Risposte di errore

| Stato | Condizione |
|--------|-----------|
| `400 Bad Request` | Il file non è un file `.json` |
| `400 Bad Request` | Contenuto JSON non valido |
| `400 Bad Request` | Conversione da JSON a XML non riuscita |
| `401 Unauthorized` | Chiave API / token JWT mancante o non valido |
| `402 Payment Required` | Quota mensile di ops esaurita |
| `402 Payment Required` | Limite di archiviazione raggiunto |
| `413 Payload Too Large` | Il file supera la dimensione massima del piano |

---

## Limiti

| Limite | Valore |
|-------|-------|
| Dimensione massima del file | Dipende dal piano (Founding: 5 MB) |
| Codifica di input | Solo UTF-8 |
| Conversioni mensili | Dipende dal piano |

## Domande frequenti

### Come converto JSON in XML con una API REST?

Invia una richiesta POST `multipart/form-data` a `/v1/convert/json-to-xml` con il file `.json` nel campo `file` e autenticati con un header `X-API-Key` o un token JWT `Authorization: Bearer`. La risposta è l'XML convertito.

### Come vengono convertiti gli array JSON in XML?

Ogni elemento dell'array viene racchiuso in un elemento `<item>` sotto l'elemento `<root>`, quindi `[{"id": 1}, {"id": 2}]` diventa `<root><item><id>1</id></item><item><id>2</id></item></root>`. L'elemento radice è sempre `<root>`.

### Posso ottenere un URL di download invece dei byte XML grezzi?

Sì. Imposta `direct_download=false` per ricevere una risposta di metadati JSON contenente `presigned_url`, `object_key`, `filename`, `file_size` e `conversion_time_seconds` invece dell'XML grezzo.

### Perché l'API JSON in XML restituisce 400 Bad Request?

Un `400` viene restituito quando il file caricato non è un file `.json`, il contenuto non è JSON valido o la conversione stessa fallisce. I file più grandi della dimensione massima del tuo piano restituiscono invece `413 Payload Too Large`.
