cURL to Python: Convert Any cURL Command to requests Code

You have a curl command — pulled out of an API's documentation, copied from a colleague's terminal history, or exported from Postman's code panel — and what you actually need isn't another way to run it from a shell. It's a working Python script. That gap between “this works when I paste it into a terminal” and “this is a function I can call from my codebase” is exactly what a curl to python conversion is for.

Typing it out by hand is slower and buggier than it looks. A JSON body's truehas to become Python's True, a form body needs data= while a JSON body needs json=, and it's easy to forget that requests has no default timeout at all. A dedicated curl to Python requests converter handles all of that in one pass — headers, JSON and form bodies, file uploads, Basic Auth, and query strings all mapped to the right keyword argument, running entirely in your browser so nothing you paste (including a bearer token or session cookie sitting in a -H flag) ever leaves your machine.

The rest of this guide is the part most curl converter online tools skip: whyeach flag maps where it does, with real before/after code for the cases you'll actually hit — the same job as the requests library itself, just applied to a curl command instead of code you're writing from scratch.

Before converting anything, you need the curl command itself. Three sources cover almost every case:

• Chrome or Edge DevTools: open the Network tab, trigger the request in the page, then right-click the request in the list → Copy → Copy as cURL(there's usually a bash variant and a cmd variant — pick bash unless you specifically need Windows cmd quoting).
• Firefox DevTools: same Network tab, right-click the request → Copy → Copy as cURL (POSIX) (there's a Copy as cURL (Windows)variant too). The output is functionally identical to Chrome's.
• Postman: open a request, click Code in the right-hand panel (the </> icon), and choose cURL from the language dropdown. Postman emits a clean, single-purpose curl command with no browser-specific noise.

This is the standard copy as curl chrome devtoolsworkflow, and it's worth understanding what you're copying: DevTools reconstructs the exact request the browser sent, including every cookie and the Authorizationheader if you were logged in. That's convenient for reproducing a bug — and exactly why converting it in a tool that uploads your paste anywhere is worth thinking twice about.

This is the part that turns a converter into something you can actually reason about, not just trust — the actual mechanics behind any curl to requests library conversion, not just a black-box convert curl command to code button. Every common curl flag has one clear equivalent in requests:

Once you can read that table fluently, you can sanity-check any converter's output line by line instead of trusting it blindly — which matters, because a converted script that silently form-encodes a JSON body, or drops a query parameter, fails in ways that don't always throw an obvious error.

Five scenarios cover almost everything you'll actually paste. Each one shows the curl command first, then the idiomatic requests equivalent — not a literal, line-by-line translation, but the version an experienced Python developer would actually write.

1. GET with query parameters

curl "https://api.example.com/search?q=climate+policy&limit=20&sort=recent"

import requests

url = "https://api.example.com/search"
params = {
    "q": "climate policy",
    "limit": 20,
    "sort": "recent",
}

response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
print(response.json())

requestshandles the percent-encoding itself, so there's no need to hand-decode a pasted query string — split it into a plain params dict and let requests build the URL.

2. POST with a JSON body

curl -X POST https://api.example.com/users \
  -H 'Content-Type: application/json' \
  -d '{"name": "Ada Lovelace", "role": "engineer", "active": true}'

import requests

url = "https://api.example.com/users"
payload = {
    "name": "Ada Lovelace",
    "role": "engineer",
    "active": True,
}

response = requests.post(url, json=payload, timeout=30)
response.raise_for_status()
print(response.json())

true becomes Python's True — capitalization that trips up hand conversion constantly. Passing the dict through json= instead of data= also means you never set Content-Type yourself; requests sets application/json and serializes the body for you.

3. Multipart file upload

curl -F "description=headshot" -F "[email protected]" https://api.example.com/upload

import requests

url = "https://api.example.com/upload"
files = {
    "description": (None, "headshot"),
    "avatar": open("photo.png", "rb"),
}

response = requests.post(url, files=files, timeout=30)
response.raise_for_status()

The (None, value) tuple tells requests that descriptionis a plain text field, not a file part, so it's written into the multipart body correctly rather than treated as a filename. Setting Content-Type manually here would actually break the request — it needs to include the multipart boundary that requests generates itself.

4. Basic Auth

curl -u demo:s3cret https://api.example.com/account

import requests

url = "https://api.example.com/account"
response = requests.get(url, auth=("demo", "s3cret"), timeout=30)
response.raise_for_status()
print(response.json())

Never commit credentials in a script like this. Read them from the environment instead: auth=(os.environ["API_USER"], os.environ["API_PASS"]).

5. Cookies and session reuse

curl -b "session_id=8f14e45; theme=dark" https://api.example.com/dashboard

import requests

url = "https://api.example.com/dashboard"
cookies = {"session_id": "8f14e45", "theme": "dark"}

response = requests.get(url, cookies=cookies, timeout=30)
response.raise_for_status()

That covers one request. When a script needs to log in and then make follow-up calls, requests.Session()is the right tool — it persists cookies the server sets across every subsequent request made through it, which is closer to what a browser (or curl's -c/-b cookie-jar pair) does than passing cookies= by hand on every call:

import requests

with requests.Session() as session:
    session.cookies.update({"theme": "dark"})

    login = session.post(
        "https://api.example.com/login",
        json={"username": "ada", "password": "s3cret"},
        timeout=30,
    )
    login.raise_for_status()

    dashboard = session.get("https://api.example.com/dashboard", timeout=30)
    dashboard.raise_for_status()
    print(dashboard.json())

requestsis still the right default for a synchronous script, and it's what this site's curl to Python requests converter targets. httpx is worth knowing about as the modern alternative, deliberately built with a requests-compatible API, plus two things requestsdoesn't have: HTTP/2 support and a native async client.

The synchronous swap is close to a drop-in replacement:

import httpx

url = "https://api.example.com/search"
params = {"q": "climate policy", "limit": 20}

response = httpx.get(url, params=params, timeout=30)
response.raise_for_status()
print(response.json())

The case for actually switching shows up once a script lives inside asyncio — a FastAPI endpoint, a background task worker, or anything issuing several requests concurrently. requests has no async mode at all; running five requests concurrently with it means five threads or five sequential calls. httpx.AsyncClient awaits them concurrently on one thread:

import asyncio
import httpx

url = "https://api.example.com/search"

async def fetch(client, request_id):
    response = await client.get(url, params={"id": request_id}, timeout=30)
    response.raise_for_status()
    return response.json()

async def main():
    async with httpx.AsyncClient() as client:
        results = await asyncio.gather(*(fetch(client, i) for i in range(5)))
        print(results)

asyncio.run(main())

If a converted script isn't already running inside async code, there's little reason to add the extra dependency — stick with requests and reach for the curl to python httpx pattern only when concurrency or HTTP/2 is an actual requirement, not a hypothetical one.

A converted script that runs without error can still behave differently from the original curl command. Four places this happens in practice:

The redirect and timeout rows are the two that actually change behavior, not just wording — worth checking by eye any time a converted script needs to match the original command exactly.

curlconverter.com is the strongest pure conversion tool out there — client-side, dozens of target languages, a VS Code extension — but it's a converter and not much else, with little explanation of why a flag maps where it does. scrapingbee.com and similar scraping-vendor sites publish curl conversion pages mainly as a funnel toward a paid scraping API subscription, so the actual conversion content tends to be thin and wrapped in upsell CTAs.

The honest read: if you need one of the 50-plus languages curlconverter.com supports, use it — breadth is a real advantage. GenKitLab's bet is narrower and different — a handful of targets (Python, fetch, Axios, Node) covered with an actual explanation of the mapping and enough worked examples that you can spot a wrong conversion yourself, instead of trusting a black box.

A curl command and a Python target are one pairing out of several — GenKitLab runs the same conversion logic across a small family of API tools, all client-side, all free:

• cURL to JavaScript Fetch Converter — the same command as browser-native fetch() code, for a frontend script or a snippet to paste into DevTools.
• cURL to Axios Converter — a config object for codebases already standardized on Axios.
• cURL to Node.js Converter — code using only Node's built-in https module, no dependency to install.
• JSON Formatter & Validator — once the converted script runs, paste the response body here to actually read it instead of squinting at a single line of minified JSON in a terminal.