# Da comando cURL a codice: fetch, PHP cURL, Python requests, Node

> Converti un comando cURL in codice fetch JavaScript, PHP cURL, Python requests o Node. Gestisce metodo, header, body JSON, bearer token, basic auth, cookie e form multipart. Client-side.

Strumento gratuito nel browser (nessun upload): https://www.mauriziofonte.it/strumenti/convertitore-curl-codice

Incolla un comando **cURL** (quello che trovi nelle docs di ogni API) e ottieni il codice equivalente in **fetch JavaScript**, **PHP cURL**, **Python requests** o **Node**. Il tool interpreta metodo (`-X`), header (`-H`), body (`-d`/`--data`/`--json`), basic auth (`-u`), cookie (`-b`) e form multipart (`-F`), e genera codice pronto da incollare. Tutto **client-side**: il comando non lascia il browser.

## Come usare il convertitore

1. **Copia il comando cURL** - Dalla documentazione di un'API (Stripe, GitHub, OpenAI, Twilio mostrano tutte esempi cURL), da un client come Postman o Insomnia (voce 'Copy as cURL'), oppure dai DevTools del browser (Network, tasto destro sulla request, 'Copy as cURL'). Incolla nel campo anche su più righe, con le continuazioni backslash: il parser le gestisce.
2. **Scegli il linguaggio target** - fetch per JavaScript nel browser o in Node 18+, PHP cURL per un backend PHP, Python requests per script e automazioni, Node per un client HTTP server-side. Ogni target emette codice idiomatico per quel linguaggio, non una traduzione letterale.
3. **Converti** - Il parser tokenizza il comando rispettando il quoting della shell, interpreta metodo, header, body, autenticazione, cookie e form, poi genera il codice equivalente. Il metodo viene dedotto come fa cURL: se c'è un `-d` senza `-X`, il metodo è POST.
4. **Copia e integra** - Copia il codice e incollalo nel tuo progetto. Sostituisci sempre i valori sensibili (bearer token, password, chiavi API) con variabili d'ambiente: un segreto committato in chiaro nel repository va considerato compromesso e ruotato.

## Perché convertire un comando cURL in codice

**cURL è la lingua franca delle API.** Apri la documentazione di Stripe, GitHub, OpenAI, Twilio o di qualunque REST API seria: gli esempi di request sono quasi sempre comandi `curl`. È il modo più conciso e neutrale rispetto al linguaggio per descrivere una chiamata HTTP: metodo, URL, header, body. Il problema nasce quando devi passare da quell'esempio da riga di comando al codice che gira davvero dentro la tua applicazione: un fetch nel frontend, un client requests in uno script Python, una chiamata cURL in un backend PHP. Questo tool fa esattamente quella traduzione, mantenendo la semantica HTTP intatta.

**Cosa interpreta il parser.** Il comando viene tokenizzato rispettando le regole di quoting della shell (apici singoli, doppi, escape con backslash), poi ogni opzione viene mappata sul concetto HTTP corrispondente:

- `-X, --request` imposta il metodo (GET, POST, PUT, PATCH, DELETE). Se manca ma è presente un body, il metodo diventa POST, esattamente come fa cURL.

- `-H, --header` aggiunge un header di request. È ripetibile: `-H "Authorization: Bearer ..." -H "Content-Type: application/json"`.

- `-d, --data / --data-raw / --data-binary` definisce il body. Più `-d` vengono concatenati con `&`. In assenza di un Content-Type esplicito, cURL usa `application/x-www-form-urlencoded`.

- `--json` (cURL 7.82+) è una scorciatoia per body più `Content-Type: application/json` più `Accept: application/json`.

- `-u, --user user:password` genera l'header `Authorization: Basic` con la coppia codificata in base64.

- `-b, --cookie` imposta l'header `Cookie`.

- `-F, --form` costruisce un body `multipart/form-data`: `-F "campo=valore"` per un campo, `-F "file=@percorso"` per un upload.

- La query string fa parte dell'URL e viene preservata così com'è.

**fetch, requests, cURL PHP, Node: quattro filosofie diverse.** Lo stesso comando produce codice molto diverso a seconda del target, e le differenze contano.

`fetch` (JavaScript) è asincrono e basato su Promise, disponibile nativamente nel browser e in Node dalla versione 18. Non serializza il JSON per te: il body va passato come stringa con `JSON.stringify(...)` e il `Content-Type` lo imposti a mano negli header. Nel browser è soggetto alle policy CORS del server di destinazione.

`requests` (Python) è sincrono e ad alto livello. Il parametro `json=` serializza il dizionario e imposta `Content-Type: application/json` automaticamente; `data=` con un dizionario produce un body form-urlencoded; `files=` gestisce il multipart; `auth=(user, password)` fa la basic auth. È il target più compatto.

La `cURL` di PHP (l'estensione libcurl) è imperativa e verbosa: `curl_init()`, una sequenza di `curl_setopt()` (`CURLOPT_CUSTOMREQUEST`, `CURLOPT_HTTPHEADER`, `CURLOPT_POSTFIELDS`, `CURLOPT_USERPWD`), poi `curl_exec()`. In cambio della verbosità offre controllo totale su TLS, timeout e redirect.

Il target `Node` usa la `fetch` globale (Node 18+), l'approccio idiomatico moderno per un client HTTP server-side, evitando il modulo `https` a basso livello basato su stream e callback.

**Header, autenticazione e body: dove sbagliano i converter approssimativi.** Un bearer token è solo un header `Authorization: Bearer <token>`, quindi passa dritto come header in ogni linguaggio. La basic auth invece va tradotta: cURL fa `-u user:pass`, ma nel codice diventa `btoa()` in JavaScript, `base64_encode()` in PHP, la tupla `auth=` in requests. Il body JSON va serializzato con la funzione giusta del linguaggio, non incollato come stringa grezza. Il multipart va oltre l'header: richiede `FormData` in JS, l'array `files=` in requests, un array associativo con `CURLFile` in PHP.

**Privacy: tutto nel browser.** Il comando che incolli spesso contiene token, chiavi API o password (i `-H "Authorization: ..."`, i `-u user:pass`). Per questo il tool lavora interamente client-side: il parsing e la generazione avvengono in JavaScript nel tuo browser, niente viene inviato a un server. Puoi convertire comandi con segreti reali senza che lascino la macchina, anche se la regola d'oro resta sostituirli con variabili d'ambiente nel codice finale.

## Glossario

- **cURL**: Client URL: strumento a riga di comando (e libreria, libcurl) per effettuare richieste HTTP e su decine di altri protocolli. È lo standard de facto per mostrare esempi di chiamate API nella documentazione.
- **fetch**: API JavaScript per le richieste HTTP, basata su Promise, nativa nei browser moderni e in Node.js dalla versione 18. Sostituisce il vecchio XMLHttpRequest con un'interfaccia più pulita e componibile.
- **requests**: Libreria HTTP di Python, sinonimo di semplicità ('HTTP for Humans'). Astrae header, sessioni, autenticazione, serializzazione JSON e multipart dietro un'API sincrona e leggibile.
- **Header HTTP**: Coppia nome:valore inviata con una richiesta o risposta HTTP per trasportare metadati: tipo di contenuto (Content-Type), autenticazione (Authorization), cookie, cache. In cURL si aggiungono con `-H`.
- **Bearer token**: Schema di autorizzazione in cui il client invia un token opaco o un JWT nell'header `Authorization: Bearer <token>`. È lo standard OAuth 2.0 per le API REST moderne.
- **Basic auth**: Autenticazione HTTP di base (RFC 7617): username e password concatenati con `:` e codificati in base64 nell'header `Authorization: Basic`. Non è cifratura: va usata solo su HTTPS.
- **Payload**: Il corpo (body) di una richiesta HTTP: i dati trasmessi al server, tipicamente JSON, form-urlencoded o multipart. In cURL si definisce con `-d`, `--data` o `--json`.
- **Multipart**: Formato `multipart/form-data` per inviare campi e file in un'unica richiesta, usato per gli upload. Ogni parte ha i propri header e un boundary separa le parti. In cURL si costruisce con `-F`.

## Domande frequenti sul convertitore cURL

### Cosa fa questo strumento?

Prende un comando `curl` (metodo, URL, header, body, autenticazione, cookie, form) e genera il codice equivalente nel linguaggio che scegli: fetch JavaScript, PHP con l'estensione cURL, Python con la libreria requests, o Node con fetch. Serve a trasformare gli esempi cURL della documentazione delle API in codice pronto da integrare nella tua applicazione, senza tradurre a mano header e opzioni.

### I dati restano nel browser?

Sì, al 100%. Il parsing del comando e la generazione del codice avvengono interamente in JavaScript nel tuo browser: niente viene inviato a un server, non c'è nessuna chiamata di rete. Puoi quindi convertire comandi che contengono segreti reali (bearer token, password in `-u`, chiavi API negli header) senza che lascino la tua macchina. Resta comunque buona pratica sostituire i segreti con variabili d'ambiente nel codice finale.

### Quali linguaggi supporta?

Quattro target: `fetch` per JavaScript (browser e Node), `fetch` per Node.js server-side, `cURL` di PHP (libcurl con `curl_setopt`), e `requests` per Python. Sono le librerie HTTP più usate nei rispettivi ecosistemi. Se ti serve un target diverso (Go, Ruby, Java, C#) la richiesta HTTP astratta è la stessa: cambia solo la sintassi del client.

### Gestisce l'autenticazione?

Sì, entrambi gli schemi comuni. Un **bearer token** passato con `-H "Authorization: Bearer ..."` resta un header e viene riportato tale e quale in ogni linguaggio. La **basic auth** passata con `-u user:password` viene tradotta idiomaticamente: `btoa('user:pass')` in fetch, `base64_encode()` o `CURLOPT_USERPWD` in PHP, la tupla `auth=(user, password)` in requests. La basic auth va sempre su HTTPS perché è solo base64, non cifratura.

### Gestisce il POST di JSON?

Sì, è il caso più frequente. Un `-d '{...}'` con `-H "Content-Type: application/json"`, oppure la scorciatoia `--json '{...}'`, viene tradotto usando la serializzazione corretta del linguaggio: `JSON.stringify()` in fetch, il parametro `json=` in requests (che imposta anche l'header), `json_encode()` con `CURLOPT_POSTFIELDS` in PHP. Il body non viene mai incollato come stringa grezza dove il linguaggio si aspetta un oggetto.

### Converte anche form multipart?

Sì. Gli `-F` diventano `FormData` in JavaScript, il parametro `files=` o `data=` in requests, un array associativo (con `CURLFile` per gli upload) in PHP. Attenzione ai riferimenti a file come `-F "file=@/percorso"`: nel codice generato diventano un riferimento a un file che devi collegare tu (un input file nel browser, un percorso reale lato server), perché il contenuto del file non è nel comando cURL.

### Posso convertire da codice a cURL (il contrario)?

Non in questa versione: il tool va in una sola direzione, da cURL a codice. Per il percorso inverso, la strada più rapida è che i browser (DevTools, tasto destro sulla request, 'Copy as cURL') e i client API come Postman e Insomnia offrono già un 'Copy as cURL' che ricostruisce il comando dalla richiesta. Un convertitore codice-a-cURL è un'estensione naturale ed è nella roadmap.

### Gestisce i cookie?

Sì. Un `-b, --cookie "nome=valore"` viene tradotto nell'header `Cookie` corrispondente. Nota però che per una gestione reale della sessione (login che imposta un cookie, richieste successive che lo riusano) serve un cookie jar: `requests.Session()` in Python, l'opzione `credentials: 'include'` in fetch, `CURLOPT_COOKIEJAR`/`CURLOPT_COOKIEFILE` in PHP. Il singolo header Cookie copre il caso statico, non il ciclo di vita della sessione.

---
Uno strumento di Maurizio Fonte, senior backend engineer. Tutti gli strumenti: https://www.mauriziofonte.it/strumenti/