Can I run cURL directly in JavaScript?

Not in the browser — cURL is a system binary, not a JavaScript library. In Node.js you can invoke it via child_process.exec(), but that spawns a real curl process for each request. Most production code uses fetch or axios instead, which are pure JavaScript HTTP clients.

What's the JavaScript equivalent of curl?

Three options: (1) fetch — built into modern browsers and Node 18+; closest to the curl experience but with a Promise-based API. (2) axios — third-party library with a cleaner API, automatic JSON parsing, and request/response interceptors. (3) Spawning real curl via child_process when you need exact curl-flag compatibility.

Should I use fetch or axios?

fetch is built-in (no install) and standards-based, so it's the right default for new code. axios is preferred when you need automatic JSON handling, request interceptors (auth refresh, retries), or streaming uploads — features fetch doesn't have built-in. For simple GET/POST, fetch is enough.

How do I set headers like curl -H in fetch?

Pass a headers object to fetch: fetch(url, { headers: { 'Authorization': 'Bearer xyz' } }). Same syntax in axios: axios.get(url, { headers: {...} }). For the curl equivalent of -H 'Content-Type: application/json' on POST, use the headers object plus body or data.

How do I pass a request body like curl --data?

fetch with JSON body: fetch(url, { method: 'POST', body: JSON.stringify({a:1}), headers: {'Content-Type': 'application/json'} }). axios is shorter: axios.post(url, {a:1}) — JSON serialization and Content-Type are automatic.

How do I use a proxy with fetch or axios?

Browser fetch can't use custom proxies — that's a browser security restriction. In Node.js, fetch supports an agent or dispatcher option for proxy routing. axios accepts a proxy option: axios.get(url, { proxy: { host: 'proxy.host', port: 8080, auth: {...} } }). For HTTPS proxies, use https-proxy-agent.

When should I shell out to real curl from Node?

Three scenarios: (1) you need exact curl-flag compatibility (e.g., --max-time, --resolve, complex --form data); (2) you need TLS fingerprint impersonation (curl-impersonate flags) for anti-bot bypass; (3) you're porting a curl-heavy bash script to Node and want to keep the existing logic. Otherwise, axios/fetch is faster and cleaner.

Is fetch faster than curl?

About the same. Both ultimately use the same OS-level networking. fetch has slightly lower overhead in Node (no process spawn) than shelling out to curl. For high-volume requests, fetch + Keep-Alive connection pooling is faster than spawning curl processes per request.

How to Use cURL in JavaScript (2026)

Alex R.

Wed May 06 2026

Quick verdict: JavaScript has no native cURL — cURL is a system binary, not a JS library. The three alternatives in 2026 are fetch (built into browsers and Node 18+, standards-based), axios (third-party with cleaner API, interceptors, automatic JSON), and shelling out to real curl via child_process when you need exact flag compatibility. For 95% of cases, fetch is the right default.

This guide covers when to pick each, working examples for sync HTTP/POST/headers/body, plus how to add proxy support to all three patterns.

Option 1: fetch (Built-In)

Available in browsers and Node 18+. No install required.

// curl https://api.example.com/items
const r = await fetch("https://api.example.com/items");
const data = await r.json();

// curl -X POST -H "Content-Type: application/json" --data '{"a":1}' https://api.example.com/items
const r = await fetch("https://api.example.com/items", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ a: 1 }),
});

// curl -H "Authorization: Bearer xyz" https://api.example.com/profile
const r = await fetch(url, { headers: { "Authorization": "Bearer xyz" } });

For Node-specific options like custom agents (proxies, custom CA), import from undici in Node 18+:

import { fetch, ProxyAgent } from "undici";

const proxyAgent = new ProxyAgent("http://USER:[email protected]:8080");
const r = await fetch("https://api.example.com", { dispatcher: proxyAgent });

Option 2: axios (Third-Party)

npm install axios

import axios from "axios";

// GET — JSON parsed automatically
const { data } = await axios.get("https://api.example.com/items");

// POST — JSON serialized automatically, Content-Type set automatically
const r = await axios.post("https://api.example.com/items", { a: 1 });

// Through a proxy
const r = await axios.get("https://api.example.com", {
  proxy: {
    protocol: "http",
    host: "proxy.spyderproxy.com",
    port: 8080,
    auth: { username: "USER", password: "PASS" },
  },
});

// HTTPS-tunneling proxy (use https-proxy-agent for HTTPS targets)
import { HttpsProxyAgent } from "https-proxy-agent";
const agent = new HttpsProxyAgent("http://USER:[email protected]:8080");
const r = await axios.get("https://api.example.com", { httpsAgent: agent });

axios interceptors (auth refresh, retries)

axios.interceptors.response.use(
  r => r,
  async (error) => {
    if (error.response?.status === 401) {
      const newToken = await refreshAuthToken();
      error.config.headers["Authorization"] = `Bearer ${newToken}`;
      return axios.request(error.config);
    }
    throw error;
  }
);

This pattern (auth refresh on 401) is much harder to write with bare fetch — it's the main reason axios still has a large user base in 2026.

Option 3: Real curl via child_process

Use when you need exact curl-flag compatibility — porting curl-heavy bash scripts to Node, or using curl-impersonate for TLS fingerprint bypass.

import { execFile } from "node:child_process";
import { promisify } from "node:util";

const exec = promisify(execFile);

// curl -I -L -s https://example.com
const { stdout } = await exec("curl", [
  "-I", "-L", "-s",
  "-x", "http://USER:[email protected]:8080",
  "--max-time", "20",
  "https://example.com",
]);
console.log(stdout);

Pros: 100% curl flag compatibility, including HEAD requests, complex timeouts, multipart forms. Cons: slow (~50-100 ms process spawn per call), uses subprocess limits, harder to capture HTTP errors cleanly.

Which One to Pick

Use case	Pick
Browser-side HTTP	fetch (or axios)
Modern Node.js (18+)	fetch
Need interceptors / auth refresh	axios
Need exact curl-flag compat	child_process + curl
TLS fingerprint impersonation (anti-bot)	child_process + curl-impersonate
Streaming large downloads	fetch (Response.body) or axios responseType: 'stream'
High volume scraping (1000+ req/s)	fetch with undici Pool