cURL to Code Converter

Q: Can it handle a multi-line curl command copied from a terminal?

Yes, including the trailing backslashes. Commands copied from documentation or from a browser's Copy as cURL are almost always spread across several lines with a backslash at the end of each, and the parser treats those as line continuations exactly as a shell would. It also handles both quoting styles correctly, which matters because a JSON body is full of spaces and colons that a naive space-splitter would break apart.

Q: Why does it warn about $(...) in my command?

Because that is a shell substitution, and its value only exists when a shell runs it. Something like -d "$(cat body.json)" means read this file and put its contents here, which cannot be resolved in a browser — the tool has no access to your filesystem. Rather than emitting code containing a meaningless literal string, it flags the substitution so you know to fill in the real value yourself. The same applies to backticks and ${VARIABLE} references.

Q: How does it decide whether my body is JSON?

First from the Content-Type header if you set one. If you did not, it looks at the shape of the body — text that starts and ends with braces or brackets and parses as valid JSON is treated as JSON. That inference matters because people routinely send JSON without declaring the header, and getting it right changes the generated code substantially: Python gets json=payload with a native dictionary rather than a string, and JavaScript gets JSON.stringify around an object literal.

Q: Does it convert Python booleans and null correctly?

Yes, and this is a detail that breaks a lot of generated code elsewhere. JSON writes true, false and null; Python writes True, False and None. A converter that emits the JSON spelling into a Python dictionary produces code that fails with a NameError the moment you run it. This tool renders a native literal for each target language rather than pasting JSON text into it, so what you copy actually runs.

Q: What happens to my API keys and tokens?

Nothing leaves your browser — the parsing and code generation both happen locally, with no request to any server. That said, the tool warns you when it spots an Authorization header, an API key or basic auth credentials in the command, because the more common risk is what happens next: pasting the generated code, secret included, into a public repository, an issue tracker or a chat message. Replace the credential with an environment variable before it goes anywhere.

Q: Which languages are supported?

Eight targets: JavaScript with fetch, JavaScript with axios, Python with requests, Node.js with the built-in https module, PHP with cURL, Go with net/http, Ruby with net/http, and C# with HttpClient. Each is written the way someone working in that language would write it rather than as a mechanical transliteration — so the C# output puts the content type on the content rather than in the header collection, which is what HttpClient actually requires.

Turn any curl command into working JavaScript, Python, PHP, Go, Ruby, Node or C# — with proper shell parsing and native literals for each language.

Your curl command

Generate code for

Generated code

Parsing and generation both happen in your browser. Your command, including any tokens in it, is never sent to a server — but do replace credentials with environment variables before sharing the generated code.

What It Does

API documentation gives you a curl command; your project is written in something else. This translates between the two. Paste the command — including the multi-line form with trailing backslashes that you get from documentation or from a browser's Copy as cURL — and get back working code in whichever of eight languages you need. The part that takes the work is the parsing. A curl command is a shell command, so its arguments follow shell quoting rules: a JSON body is full of spaces, a header contains a colon, and single and double quotes behave differently from each other. Splitting on whitespace produces nonsense. This tool implements the quoting properly, then generates code that reads the way a person in that language would have written it, with native literals rather than JSON text pasted into a foreign syntax.

When to Use It

An API's documentation shows only curl examples and you need the equivalent in the language your service is actually written in.
You captured a request from your browser's network tab as Copy as cURL and want to reproduce it in a script.
A support ticket includes a curl command that reproduces a bug and you need it as a test case in your codebase.
You are moving a shell script full of curl calls into a proper application and want a starting point for each request.
You want to check how a request's headers and body will be structured before writing the client code by hand.

Worked Examples

curl -X POST 'https://api.example.com/v1/users' -H 'Content-Type: application/json' -H 'Authorization: Bearer tok_123' -d '{"name":"Jane","admin":true,"age":30}'

The standard shape of an API write. Watch the Python output in particular: the body becomes a real dictionary with True rather than the JSON spelling, so the code runs as pasted instead of raising a NameError.

curl 'https://api.example.com/search?q=hello+world&page=2' -H 'Accept: application/json'

A plain GET with query parameters. No -X flag and no body, so the method defaults to GET exactly as curl itself would, and the generated code correctly omits any body-writing step.

curl -u admin:s3cret -X DELETE https://api.example.com/v1/sessions/42 -L

Basic authentication and a redirect follow. Each language gets its own idiom for the credentials — SetBasicAuth in Go, auth= in Python, basic_auth in Ruby — rather than a hand-built Authorization header.

Features

Eight target languages including Python

PHP and C#

Proper shell-quoting parser for single and double quotes

Multi-line commands with backslash continuations

JSON bodies rendered as native literals per language

Automatic body-type detection from header or shape

Basic auth mapped to each language's own idiom

Warnings for credentials

plain HTTP and skipped TLS checks

Detection of shell substitutions that cannot be resolved

Query parameters and headers listed separately

Entirely browser-based with no uploads

How to Use

1. Paste your curl command — multi-line with backslashes is fine. 2. Pick the target language from the selector. 3. The generated code appears immediately, along with a breakdown of the method, URL, headers and body it parsed. 4. Check any warnings, particularly about credentials, before copying. 5. Click Copy to take the code.

Common Mistakes

Splitting a curl command on spaces to parse it. A JSON body and almost every header contain spaces, so the arguments come apart in the wrong places and the result is silently wrong rather than obviously broken.
Pasting JSON text into a Python dictionary. true, false and null are not Python literals, and code that looks right fails with a NameError the first time it runs.
Leaving the token in the generated code. The credential from the curl command travels straight into whatever you paste next, which is how API keys end up in public repositories.
Assuming a command with no -X flag is a GET. curl switches to POST as soon as there is a body, so copying the method from the flag alone gets it wrong exactly when a body is present.
Expecting $(...) or a file reference like -d @body.json to be resolved. Those need a shell and a filesystem, so the generated code can only mark the spot where the real value belongs.

Frequently Asked Questions

Can it handle a multi-line curl command copied from a terminal?

Why does it warn about $(...) in my command?

How does it decide whether my body is JSON?

Does it convert Python booleans and null correctly?

What happens to my API keys and tokens?

Which languages are supported?

Related Tools

URL Parser & Query String Splitter