How to Use cURL in JavaScript: Fetch, Axios, and Best Practices

TL;DR

• Fetch is the built-in JavaScript equivalent of cURL and works in both browsers and Node.js 18+ with no dependencies
• Axios is the recommended default for Node.js projects thanks to automatic JSON parsing, better error handling, and built-in timeouts
• Running cURL via child_process works, but it's best kept for quick scripts or when you already have a working command
• node-libcurl gives you full libcurl power, but it's a niche choice for advanced networking needs
• Translating cURL to JavaScript is a flag-by-flag mapping, not a one-to-one copy-and-paste
• Proxies are essential for scraping at scale, and neither Fetch nor Axios supports them natively without extra setup
• If you're dealing with CAPTCHAs or heavy bot protection, switching to a scraping API is more practical than tweaking HTTP clients

What "cURL in JavaScript" actually means

Before writing any code, it helps to understand the split. cURL is a command-line tool. It runs on your system, not in a browser. You can't call it from browser-side JavaScript – browsers simply don't allow your code to run system programs.

The answer depends on where your JavaScript runs.

In the browser, you use the Fetch API. It can do the same things cURL does – send GET and POST requests, set custom headers, and include a request body. The one catch is CORS. If you're making a request to a different domain, the server on the other end has to allow it explicitly. A cURL command might fail in the browser, not because your code is wrong, but because the server never said, "yes, other websites can call me." There's no client-side workaround for this.

In Node.js, you have two options. You can run the actual cURL program from your script using the built-in child_process module – basically telling Node.js "run this terminal command for me and give me the result." Or you can skip cURL entirely and use a JavaScript HTTP library (Fetch, Axios, or node-libcurl) that makes the same kinds of requests without needing cURL installed at all.

The practical takeaway: for almost every JavaScript project, using a built-in HTTP library is the better choice. It works everywhere your code runs, it's easier to test, and it doesn't break when someone deploys to a server that doesn't have cURL installed. Shelling out to cURL has its place, but it's the exception.

If you're coming from a cURL-heavy workflow, it's worth brushing up on how cURL GET requests work and how cURL handles proxies before diving into the JavaScript equivalents below.

Running system cURL from Node.js with child_process

The most literal way to use cURL in JavaScript – tell Node.js to run a cURL command in the terminal and hand back the output. It's not elegant, but it gets the job done when you already have a working cURL command and just need it to run from a Node.js script.

You'd reach for this approach when you're migrating a shell script to Node.js, automating something quick, or dealing with a cURL command so complex that translating it to Fetch or Axios isn't worth the effort.

Basic GET request with exec()

The child_process module is built into Node.js with no installation required. The exec() function runs a shell command and gives you the output as a string.

const { exec } = require('child_process');

exec('curl -s https://jsonplaceholder.typicode.com/posts/1', (error, stdout, stderr) => {
  if (error) {
    console.error('Command failed:', error.message);
    return;
  }

  if (stderr) {
    console.error('cURL error output:', stderr);
    return;
  }

  const data = JSON.parse(stdout);
  console.log(data.title);
});

const { exec } = require('child_process');

exec('curl -s https://jsonplaceholder.typicode.com/posts/1', (error, stdout, stderr) => {
  if (error) {
    console.error('Command failed:', error.message);
    return;
  }

  if (stderr) {
    console.error('cURL error output:', stderr);
    return;
  }

  const data = JSON.parse(stdout);
  console.log(data.title);
});

The -s flag tells cURL to run silently (no progress bar). Without it, you'll get download stats mixed into your output, which makes JSON parsing a mess.

Step-by-step breakdown:

• exec() runs the cURL command in a child shell process.
• When the command finishes, the callback fires with three arguments – error (if the command itself failed), stdout (the response body), and stderr (any error output from cURL).
• Since stdout is a raw string, you need to JSON.parse() it yourself. There's no automatic parsing here.

Synchronous version with execSync()

If you're writing a simple script and don't need async behavior, execSync() blocks until the command finishes and returns the output directly.

const { execSync } = require('child_process');

try {
  const output = execSync('curl -s https://jsonplaceholder.typicode.com/users/1');
  const user = JSON.parse(output.toString());
  console.log(user.name, user.email);
} catch (error) {
  console.error('Request failed:', error.message);
}

const { execSync } = require('child_process');

try {
  const output = execSync('curl -s https://jsonplaceholder.typicode.com/users/1');
  const user = JSON.parse(output.toString());
  console.log(user.name, user.email);
} catch (error) {
  console.error('Request failed:', error.message);
}

Simpler to read, but it freezes your entire Node.js process until cURL returns. Fine for a quick script, not something you want in a server.

Sending a POST request

When you need to send data, like creating a new resource, the cURL command gets longer. Here's a POST request with a JSON body:

const { exec } = require('child_process');

const command = `curl -s -X POST https://jsonplaceholder.typicode.com/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "Test post", "body": "Hello from cURL", "userId": 1}'`;

exec(command, (error, stdout, stderr) => {
  if (error) {
    console.error('Command failed:', error.message);
    return;
  }

  const response = JSON.parse(stdout);
  console.log('Created post with ID:', response.id);
});

const { exec } = require('child_process');

const command = `curl -s -X POST https://jsonplaceholder.typicode.com/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "Test post", "body": "Hello from cURL", "userId": 1}'`;

exec(command, (error, stdout, stderr) => {
  if (error) {
    console.error('Command failed:', error.message);
    return;
  }

  const response = JSON.parse(stdout);
  console.log('Created post with ID:', response.id);
});

Notice how the command string is getting unwieldy. You're building a shell command inside a JavaScript string, juggling quotes inside quotes, escaping things. It works, but you can probably feel why this approach doesn't scale.

Safer execution with spawnSync()

When your cURL command has many flags and headers, building it as a single string invites shell-injection problems. spawnSync() takes an array of arguments instead, so each flag is a separate element.

const { spawnSync } = require('child_process');

const result = spawnSync('curl', [
  '-s',
  '-X', 'GET',
  '-H', 'Accept: application/json',
  '-H', 'User-Agent: my-node-script/1.0',
  'https://jsonplaceholder.typicode.com/posts?_limit=3'
]);

if (result.error) {
  console.error('Failed to run cURL:', result.error.message);
} else if (result.status !== 0) {
  console.error('cURL exited with code:', result.status);
  console.error(result.stderr.toString());
} else {
  const posts = JSON.parse(result.stdout.toString());
  posts.forEach(post => console.log(`- ${post.title}`));
}

const { spawnSync } = require('child_process');

const result = spawnSync('curl', [
  '-s',
  '-X', 'GET',
  '-H', 'Accept: application/json',
  '-H', 'User-Agent: my-node-script/1.0',
  'https://jsonplaceholder.typicode.com/posts?_limit=3'
]);

if (result.error) {
  console.error('Failed to run cURL:', result.error.message);
} else if (result.status !== 0) {
  console.error('cURL exited with code:', result.status);
  console.error(result.stderr.toString());
} else {
  const posts = JSON.parse(result.stdout.toString());
  posts.forEach(post => console.log(`- ${post.title}`));
}

Each argument is its own array element, so there's no risk of a malformed string accidentally running something you didn't intend. If you're passing any dynamic input into a cURL command (URLs from user input, variable header values), always use spawnSync() or spawn() over exec().

When this approach falls apart

cURL inside JavaScript works, but let's be honest about the trade-offs:

• cURL must be installed. If your code runs on a minimal Docker image, a serverless function, or a CI environment that strips non-essential binaries, cURL might not be there.
• Output is just a string. You're parsing raw text every time. If cURL returns an unexpected error page instead of JSON, your script crashes unless you've wrapped everything carefully.
• It's hard to test. Mocking a child process is significantly more annoying than mocking an HTTP client.
• Error handling is clunky. HTTP status codes aren't surfaced automatically – you'd need to add -w "%{http_code}" to the cURL command and parse it out of the output yourself.

For a one-off script or a quick migration, shelling out to cURL is perfectly fine. For anything that'll run in production, other options mentioned further below handle all of this more cleanly.

Using node-libcurl for direct libcurl bindings

If child_process is "run cURL from JavaScript," node-libcurl is "put cURL's engine inside JavaScript." It's a native addon that wraps libcurl and exposes it directly to Node.js. You get full access to libcurl's feature set without shelling out to anything.

That said, this is a specialist tool. For most projects, Fetch or Axios is simpler and more than enough. You'd reach for node-libcurl when you specifically need low-level TLS configuration, custom cipher suites, CURLOPT_* options, or multi-handle concurrency for high-throughput scraping. If none of that means anything to you yet, you can safely skip to the next section and come back here if you ever need it.

Installation

Install node-libcurl with:

npm install node-libcurl

npm install node-libcurl

One thing to know upfront: node-libcurl is a native addon, which means it compiles C++ code during installation. It needs node-gyp and a C++ build toolchain on your system. On most dev machines, this is already there. In CI pipelines or Docker containers, you might need to install build tools first – and that can turn a 5-second npm install into a minor adventure.

GET request with the curly interface

node-libcurl has a few API levels. The simplest is curly, a convenience wrapper that gives you async/await syntax and feels closer to what you'd expect from a modern JavaScript HTTP client.

const { curly } = require('node-libcurl');

async function getPost() {
  try {
    const { statusCode, data } = await curly.get(
      'https://jsonplaceholder.typicode.com/posts/1'
    );

    console.log('Status:', statusCode);
    console.log('Title:', data.title);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getPost();

const { curly } = require('node-libcurl');

async function getPost() {
  try {
    const { statusCode, data } = await curly.get(
      'https://jsonplaceholder.typicode.com/posts/1'
    );

    console.log('Status:', statusCode);
    console.log('Title:', data.title);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getPost();

curly automatically parses JSON responses, so data is already an object. The statusCode comes back as a number. It's fairly clean for what's happening under the hood – a full libcurl request cycle.

POST request with curly

Send a POST request with a JSON body:

const { curly } = require('node-libcurl');

async function createPost() {
  try {
    const { statusCode, data } = await curly.post(
      'https://jsonplaceholder.typicode.com/posts',
      {
        postFields: JSON.stringify({
          title: 'Test post',
          body: 'Sent via node-libcurl',
          userId: 1,
        }),
        httpHeader: [
          'Content-Type: application/json',
        ],
      }
    );

    console.log('Status:', statusCode);
    console.log('Created post ID:', data.id);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

createPost();

const { curly } = require('node-libcurl');

async function createPost() {
  try {
    const { statusCode, data } = await curly.post(
      'https://jsonplaceholder.typicode.com/posts',
      {
        postFields: JSON.stringify({
          title: 'Test post',
          body: 'Sent via node-libcurl',
          userId: 1,
        }),
        httpHeader: [
          'Content-Type: application/json',
        ],
      }
    );

    console.log('Status:', statusCode);
    console.log('Created post ID:', data.id);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

createPost();

Notice the differences from Fetch or Axios. Headers are passed as an array of strings ("Key: Value" format) rather than an object. The body goes into postFields as a string. It's not hard, just different – the naming mirrors libcurl's C API, which is why it feels a bit alien if you're used to JavaScript conventions.

Using the Curl class for fine-grained control

When you need access to specific CURLOPT_* options, the lower-level Curl class gives you full control:

const { Curl, CurlCode } = require('node-libcurl');

const curl = new Curl();

curl.setOpt('URL', 'https://jsonplaceholder.typicode.com/posts/1');
curl.setOpt('FOLLOWLOCATION', true);
curl.setOpt('TIMEOUT', 10);
curl.setOpt('HTTPHEADER', [
  'Accept: application/json',
  'User-Agent: my-node-script/1.0',
]);

curl.on('end', (statusCode, body, headers) => {
  console.log('Status:', statusCode);
  console.log('Title:', JSON.parse(body).title);
  curl.close();
});

curl.on('error', (error, errorCode) => {
  console.error('Request failed:', error.message);
  console.error('cURL error code:', errorCode);
  curl.close();
});

curl.perform();

const { Curl, CurlCode } = require('node-libcurl');

const curl = new Curl();

curl.setOpt('URL', 'https://jsonplaceholder.typicode.com/posts/1');
curl.setOpt('FOLLOWLOCATION', true);
curl.setOpt('TIMEOUT', 10);
curl.setOpt('HTTPHEADER', [
  'Accept: application/json',
  'User-Agent: my-node-script/1.0',
]);

curl.on('end', (statusCode, body, headers) => {
  console.log('Status:', statusCode);
  console.log('Title:', JSON.parse(body).title);
  curl.close();
});

curl.on('error', (error, errorCode) => {
  console.error('Request failed:', error.message);
  console.error('cURL error code:', errorCode);
  curl.close();
});

curl.perform();

This is where node-libcurl earns its keep. Every option you can set in a cURL command with --something, you can set here with curl.setOpt(). Verbose output, custom DNS resolution, specific TLS versions, and proxy tunneling are all available.

Fetch API: The native JavaScript HTTP client

If you're starting a new project and wondering which HTTP client to use, start here. Fetch is built into every modern browser and comes with Node.js 18+ as a global – no packages, no imports, no npm install. It's just there.

For most developers looking for a cURL equivalent in JavaScript, Fetch is the answer. It won't do everything cURL can, but it covers the vast majority of use cases with zero dependencies.

Basic GET request

async function getPost() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts/1');
    const data = await response.json();
    console.log(data.title);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getPost();

async function getPost() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts/1');
    const data = await response.json();
    console.log(data.title);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getPost();

Two lines to make a request and parse the response. That's it. No modules to require, no clients to instantiate. If you're on Node.js 16 or below, you'll need the node-fetch package to get the same API, but from Node.js 18 onward, fetch() is global just like it is in the browser.

POST request with a JSON body

Sending data works the same way a cURL POST does. You specify the method, set the content type, and pass the body. The syntax is just more verbose than a one-liner in the terminal.

async function createPost() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        title: 'Test post',
        body: 'Sent via Fetch',
        userId: 1,
      }),
    });

    const data = await response.json();
    console.log('Created post ID:', data.id);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

createPost();

async function createPost() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        title: 'Test post',
        body: 'Sent via Fetch',
        userId: 1,
      }),
    });

    const data = await response.json();
    console.log('Created post ID:', data.id);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

createPost();

One thing that trips people up: the body must be a string. You can't pass a plain JavaScript object, and you need JSON.stringify() every time. Axios handles this automatically, which is one reason people reach for it instead.

Custom headers

The headers option takes a plain object. Each key-value pair is equivalent to an -H flag in cURL.

const response = await fetch('https://api.github.com/user', {
  headers: {
    'Authorization': 'Bearer ghp_your_token_here',
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'my-node-script/1.0',
  },
});

const response = await fetch('https://api.github.com/user', {
  headers: {
    'Authorization': 'Bearer ghp_your_token_here',
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'my-node-script/1.0',
  },
});

You can also use the headers constructor if you need to build headers programmatically, but for most cases, the plain object works fine.

Handling errors

Here's the thing about Fetch that catches almost everyone the first time: it doesn't throw on HTTP errors. A 404, a 500, a 403 – Fetch considers all of these successful responses because the server did respond. It only throws on actual network failures, like the server being unreachable.

async function getPost() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts/9999');

    if (!response.ok) {
      console.error(`Server returned ${response.status}: ${response.statusText}`);
      return;
    }

    const data = await response.json();
    console.log(data.title);
  } catch (error) {
    // This only fires on network errors, not HTTP errors
    console.error('Network error:', error.message);
  }
}

getPost();

async function getPost() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/posts/9999');

    if (!response.ok) {
      console.error(`Server returned ${response.status}: ${response.statusText}`);
      return;
    }

    const data = await response.json();
    console.log(data.title);
  } catch (error) {
    // This only fires on network errors, not HTTP errors
    console.error('Network error:', error.message);
  }
}

getPost();

Always check the response.ok before parsing the body. If you skip this, you'll eventually try to JSON.parse() an HTML error page and spend 20 minutes wondering why your data is undefined.

Timeouts

cURL has --max-time. Axios has a timeout option. Fetch has... nothing. By default, a Fetch request will hang indefinitely if the server never responds. You need to wire up an AbortController yourself.

async function fetchWithTimeout(url, timeoutMs = 5000) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const response = await fetch(url, { signal: controller.signal });
    clearTimeout(timeoutId);

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    return await response.json();
  } catch (error) {
    clearTimeout(timeoutId);

    if (error.name === 'AbortError') {
      throw new Error(`Request timed out after ${timeoutMs}ms`);
    }

    throw error;
  }
}

async function fetchWithTimeout(url, timeoutMs = 5000) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);

  try {
    const response = await fetch(url, { signal: controller.signal });
    clearTimeout(timeoutId);

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    return await response.json();
  } catch (error) {
    clearTimeout(timeoutId);

    if (error.name === 'AbortError') {
      throw new Error(`Request timed out after ${timeoutMs}ms`);
    }

    throw error;
  }
}

It's not a lot of code, but it's code you have to write every time, or abstract into a helper. This is one of the biggest practical arguments for Axios over raw Fetch in production scraping work.

CORS in the browser

If you're running Fetch in the browser and making requests to a different domain, CORS rules apply. The server has to include Access-Control-Allow-Origin in its response headers, or the browser blocks the response before your code ever sees it.

This is why a cURL command can work perfectly in the terminal but fail the moment you paste the same logic into browser-side JavaScript. cURL doesn't care about CORS – it's not a browser. But fetch() in the browser absolutely does.

There's no client-side fix. Your options are:

• Ask the API provider to add CORS headers (sometimes possible, often not)
• Proxy the request through your own server, where CORS doesn't apply
• Use a serverless function as a middleman between your frontend and the target API

If you're doing web scraping with JavaScript, this is a non-issue – scraping runs server-side in Node.js, where CORS doesn't exist.

Axios: the developer-friendly HTTP library

Note: On March 31, 2026, an attacker compromised the npm credentials of a lead Axios maintainer and published two backdoored versions – 1.14.1 and 0.30.4. Both contained a hidden dependency that silently installed a cross-platform remote access trojan on any system that ran npm install. The malicious versions were live for roughly three hours before npm pulled them. If you installed Axios during that window, treat the system as compromised, roll back to 1.14.0 or 0.30.3, and rotate any credentials that were accessible on the affected machine.

With that out of the way, Axios is still one of the most popular HTTP libraries in the JavaScript ecosystem for good reason. It works in both Node.js and the browser, parses JSON automatically, has built-in timeout support, and gives you cleaner error handling than raw Fetch. For Node.js projects that need more ergonomics than fetch() offers, it's been the go-to choice for years.

Installation

npm install axios@1.14.0

npm install axios@1.14.0

We're pinning to 1.14.0 here deliberately.

Basic GET request

const axios = require('axios');

async function getPost() {
  try {
    const response = await axios.get(
      'https://jsonplaceholder.typicode.com/posts/1'
    );
    console.log(response.data.title);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getPost();

const axios = require('axios');

async function getPost() {
  try {
    const response = await axios.get(
      'https://jsonplaceholder.typicode.com/posts/1'
    );
    console.log(response.data.title);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getPost();

Notice what's missing compared to Fetch: no .json() call. Axios detects the Content-Type header and parses the response body automatically. response.data is already a JavaScript object. It's a small thing, but it adds up over hundreds of requests.

POST request

Sending a POST request is similarly streamlined. Pass a JavaScript object directly, and Axios serializes it to JSON and sets the Content-Type header for you.

const axios = require('axios');

async function createPost() {
  try {
    const response = await axios.post(
      'https://jsonplaceholder.typicode.com/posts',
      {
        title: 'Test post',
        body: 'Sent via Axios',
        userId: 1,
      }
    );
    console.log('Created post ID:', response.data.id);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

createPost();

const axios = require('axios');

async function createPost() {
  try {
    const response = await axios.post(
      'https://jsonplaceholder.typicode.com/posts',
      {
        title: 'Test post',
        body: 'Sent via Axios',
        userId: 1,
      }
    );
    console.log('Created post ID:', response.data.id);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

createPost();

No JSON.stringify(), no manual Content-Type header. Compare this to the Fetch version of the same request, and you'll see why people reach for Axios.

Custom headers

Setting headers works like cURL's -H flag – pass them as an object in the config parameter.

const axios = require('axios');

async function getGitHubUser() {
  try {
    const response = await axios.get('https://api.github.com/user', {
      headers: {
        'Authorization': 'Bearer ghp_your_token_here',
        'Accept': 'application/vnd.github.v3+json',
        'User-Agent': 'my-node-script/1.0',
      },
    });
    console.log(response.data.login);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getGitHubUser();

const axios = require('axios');

async function getGitHubUser() {
  try {
    const response = await axios.get('https://api.github.com/user', {
      headers: {
        'Authorization': 'Bearer ghp_your_token_here',
        'Accept': 'application/vnd.github.v3+json',
        'User-Agent': 'my-node-script/1.0',
      },
    });
    console.log(response.data.login);
  } catch (error) {
    console.error('Request failed:', error.message);
  }
}

getGitHubUser();

Timeout

One of Axios's biggest practical advantages over Fetch is the timeout:

const response = await axios.get('https://slow-api.example.com/data', {
  timeout: 5000, // 5 seconds
});

const response = await axios.get('https://slow-api.example.com/data', {
  timeout: 5000, // 5 seconds
});

If the server doesn't respond within the limit, Axios throws an error with code: 'ECONNABORTED'.

Error handling

Unlike Fetch, Axios actually throws errors on 4xx and 5xx responses. This means your catch block handles both network failures and HTTP errors, which is usually what you want.

const axios = require('axios');
async function getPost() {
  try {
    const response = await axios.get(
      'https://jsonplaceholder.typicode.com/posts/9999'
    );
    console.log(response.data);
  } catch (error) {
    if (error.response) {
      // Server responded with a non-2xx status
      console.error('Status:', error.response.status);
      console.error('Body:', error.response.data);
    } else if (error.request) {
      // Request was sent, but no response received
      console.error('No response from server');
    } else {
      // Something went wrong setting up the request
      console.error('Setup error:', error.message);
    }
  }
}

getPost();

const axios = require('axios');
async function getPost() {
  try {
    const response = await axios.get(
      'https://jsonplaceholder.typicode.com/posts/9999'
    );
    console.log(response.data);
  } catch (error) {
    if (error.response) {
      // Server responded with a non-2xx status
      console.error('Status:', error.response.status);
      console.error('Body:', error.response.data);
    } else if (error.request) {
      // Request was sent, but no response received
      console.error('No response from server');
    } else {
      // Something went wrong setting up the request
      console.error('Setup error:', error.message);
    }
  }
}

getPost();

The three-tier structure (error.response, error.request, error.message) covers every failure mode. You'll know exactly where things went wrong without parsing status codes out of a raw string.

Interceptors

This is where Axios pulls ahead for any project with more than a handful of requests. Interceptors let you run logic on every request or response globally – add auth headers, log requests, implement retry logic, all without touching individual calls.

const axios = require('axios');

// Add an auth header to every outgoing request
axios.interceptors.request.use((config) => {
  config.headers['Authorization'] = `Bearer ${process.env.API_TOKEN}`;
  return config;
});

// Log every failed response
axios.interceptors.response.use(
  (response) => response,
  (error) => {
    if (error.response) {
      console.error(
        `[${error.response.status}] ${error.config.method.toUpperCase()} ${error.config.url}`
      );
    }
    return Promise.reject(error);
  }
);

const axios = require('axios');

// Add an auth header to every outgoing request
axios.interceptors.request.use((config) => {
  config.headers['Authorization'] = `Bearer ${process.env.API_TOKEN}`;
  return config;
});

// Log every failed response
axios.interceptors.response.use(
  (response) => response,
  (error) => {
    if (error.response) {
      console.error(
        `[${error.response.status}] ${error.config.method.toUpperCase()} ${error.config.url}`
      );
    }
    return Promise.reject(error);
  }
);

For scraping, a response interceptor that retries on 429 (rate limit) or 503 (server overload) with exponential backoff is practically essential. You wire it up once and forget about it.

Creating a reusable instance

When all your requests share the same base URL, auth headers, and timeout, create a configured instance with axios.create() instead of repeating the same config everywhere.

const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.github.com',
  timeout: 10000,
  headers: {
    'Authorization': `Bearer ${process.env.GITHUB_TOKEN}`,
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'my-node-script/1.0',
  },
});

// Now every call uses the shared config
const user = await api.get('/user');
const repos = await api.get('/user/repos');

const axios = require('axios');

const api = axios.create({
  baseURL: 'https://api.github.com',
  timeout: 10000,
  headers: {
    'Authorization': `Bearer ${process.env.GITHUB_TOKEN}`,
    'Accept': 'application/vnd.github.v3+json',
    'User-Agent': 'my-node-script/1.0',
  },
});

// Now every call uses the shared config
const user = await api.get('/user');
const repos = await api.get('/user/repos');

This also keeps connection pools alive between requests, which matters when you're hitting the same API hundreds of times. Create the instance once, reuse it everywhere.

Translating cURL commands to JavaScript

This is the section you'll probably need to bookmark. You have a cURL command, and you need it in JavaScript. Rather than guessing, here's a systematic way to translate any cURL command flag by flag.

The "copy as cURL" workflow

Before you translate anything, you need the cURL command. If you're trying to replicate a request your browser made, Chrome and Firefox hand it to you for free:

1. Open DevTools (F12 or Ctrl+Shift+I).
2. Go to the Network tab.
3. Find the request you want to replicate.
4. Right-click it and select Copy, then Copy as cURL.

That gives you the exact command as a cURL string. This is the fastest way to get a working starting point, especially when you're debugging why your JavaScript request behaves differently from what the browser sent.

Flag-by-flag mapping

Here's how each common cURL flag translates to Fetch and Axios. If you've been following along with the earlier sections, most of these will look familiar.

Full example: translating a real cURL command

Let's take a GitHub API request that creates an issue – the kind of command you'd realistically copy from documentation or DevTools.

The cURL version:

curl -X POST https://api.github.com/repos/octocat/hello-world/issues \
  -H "Authorization: Bearer ghp_your_token_here" \
  -H "Accept: application/vnd.github.v3+json" \
  -H "User-Agent: my-script/1.0" \
  -d '{"title": "Bug report", "body": "Something is broken", "labels": ["bug"]}'

curl -X POST https://api.github.com/repos/octocat/hello-world/issues \
  -H "Authorization: Bearer ghp_your_token_here" \
  -H "Accept: application/vnd.github.v3+json" \
  -H "User-Agent: my-script/1.0" \
  -d '{"title": "Bug report", "body": "Something is broken", "labels": ["bug"]}'

Translated to Fetch:

async function createIssue() {
  const response = await fetch(
    'https://api.github.com/repos/octocat/hello-world/issues',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer ghp_your_token_here',
        'Accept': 'application/vnd.github.v3+json',
        'User-Agent': 'my-script/1.0',
      },
      body: JSON.stringify({
        title: 'Bug report',
        body: 'Something is broken',
        labels: ['bug'],
      }),
    }
  );

  if (!response.ok) {
    throw new Error(`GitHub API returned ${response.status}`);
  }

  const issue = await response.json();
  console.log('Created issue:', issue.html_url);
}

async function createIssue() {
  const response = await fetch(
    'https://api.github.com/repos/octocat/hello-world/issues',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer ghp_your_token_here',
        'Accept': 'application/vnd.github.v3+json',
        'User-Agent': 'my-script/1.0',
      },
      body: JSON.stringify({
        title: 'Bug report',
        body: 'Something is broken',
        labels: ['bug'],
      }),
    }
  );

  if (!response.ok) {
    throw new Error(`GitHub API returned ${response.status}`);
  }

  const issue = await response.json();
  console.log('Created issue:', issue.html_url);
}

Translated to Axios:

const axios = require('axios');

async function createIssue() {
  const response = await axios.post(
    'https://api.github.com/repos/octocat/hello-world/issues',
    {
      title: 'Bug report',
      body: 'Something is broken',
      labels: ['bug'],
    },
    {
      headers: {
        'Authorization': 'Bearer ghp_your_token_here',
        'Accept': 'application/vnd.github.v3+json',
        'User-Agent': 'my-script/1.0',
      },
    }
  );

  console.log('Created issue:', response.data.html_url);
}

const axios = require('axios');

async function createIssue() {
  const response = await axios.post(
    'https://api.github.com/repos/octocat/hello-world/issues',
    {
      title: 'Bug report',
      body: 'Something is broken',
      labels: ['bug'],
    },
    {
      headers: {
        'Authorization': 'Bearer ghp_your_token_here',
        'Accept': 'application/vnd.github.v3+json',
        'User-Agent': 'my-script/1.0',
      },
    }
  );

  console.log('Created issue:', response.data.html_url);
}

Same result, different trade-offs. The Fetch version is more explicit, as you see every step. The Axios version is shorter because it handles JSON serialization and POST body formatting automatically. Neither is wrong; it depends on what your project already uses and how much boilerplate you're willing to manage.

Translating basic auth

cURL's -u flag trips people up because there's no direct one-to-one option in Fetch. You need to construct the Authorization header with a Base64-encoded string manually.

cURL:

curl -u admin:secretpass https://api.example.com/protected

curl -u admin:secretpass https://api.example.com/protected

Fetch:

const response = await fetch('https://api.example.com/protected', {
  headers: {
    'Authorization': 'Basic ' + btoa('admin:secretpass'),
  },
});

const response = await fetch('https://api.example.com/protected', {
  headers: {
    'Authorization': 'Basic ' + btoa('admin:secretpass'),
  },
});

Meanwhile, Axios has a dedicated auth option that does this for you:

const response = await axios.get('https://api.example.com/protected', {
  auth: {
    username: 'admin',
    password: 'secretpass',
  },
});

const response = await axios.get('https://api.example.com/protected', {
  auth: {
    username: 'admin',
    password: 'secretpass',
  },
});

Downloading files

cURL's -o flag saves the response directly to a file. In JavaScript, you fetch the response as binary data and write it yourself.

cURL:

curl -o report.pdf https://example.com/files/report.pdf

curl -o report.pdf https://example.com/files/report.pdf

Fetch (Node.js):

const fs = require('fs');

async function downloadFile() {
  const response = await fetch('https://example.com/files/report.pdf');
  const buffer = Buffer.from(await response.arrayBuffer());
  fs.writeFileSync('report.pdf', buffer);
  console.log('Downloaded report.pdf');
}