Cách Dùng cURL Trong JavaScript: Fetch, Axios Và Node.js

Dùng cURL trong JavaScript thường không có nghĩa sao chép nguyên lệnh terminal vào file .js. Trong phần lớn dự án, bạn sẽ chuyển URL, method, header và body của lệnh cURL sang Fetch hoặc Axios. Chỉ khi cần sử dụng đúng binary cURL, Node.js mới gọi chương trình hệ thống qua child_process hoặc dùng binding như node-libcurl.

Ví dụ, lệnh cURL:

curl https://api.example.com/posts/1 \
  -H "Accept: application/json"

có thể chuyển sang Fetch như sau:

const response = await fetch('https://api.example.com/posts/1', {
  headers: {
    Accept: 'application/json',
  },
});

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

const data = await response.json();
console.log(data);

Đây là lựa chọn nên ưu tiên cho đa số ứng dụng JavaScript hiện đại. Bài viết dưới đây giải thích cách chuyển từng thành phần của cURL sang Fetch, Axios hoặc Node.js, đồng thời xử lý CORS, timeout, lỗi HTTP, xác thực và proxy đúng cách.

cURL trong JavaScript thực chất là gì?

cURL là công cụ dòng lệnh dùng để gửi và nhận dữ liệu qua nhiều giao thức. JavaScript là ngôn ngữ chạy trong trình duyệt hoặc runtime như Node.js. Vì vậy, cụm từ “chạy cURL trong JavaScript” có thể chỉ ba nhu cầu khác nhau:

  1. Chuyển một lệnh cURL thành request Fetch.

  2. Chuyển cURL sang Axios hoặc HTTP client khác.

  3. Gọi binary curl thật từ chương trình Node.js.

Trong trình duyệt, JavaScript không được phép tùy ý chạy chương trình của hệ điều hành. Bạn không thể gọi trực tiếp binary cURL từ mã frontend. Fetch hoặc XMLHttpRequest mới là công cụ phù hợp, và request còn chịu chính sách CORS của trình duyệt.

Trong Node.js, bạn có thể dùng Fetch, Axios, module HTTP hoặc child_process. Với code ứng dụng, Fetch/Axios thường dễ kiểm thử, dễ triển khai và không phụ thuộc máy chủ đã cài cURL hay chưa.

Nên chọn Fetch, Axios hay gọi cURL trực tiếp?

Phương án Khi nên dùng Điểm cần lưu ý
Fetch Dự án mới, cần ít dependency, chạy browser hoặc Node.js hiện đại Phải tự kiểm tra response.ok; timeout dùng AbortSignal
Axios Dự án cần interceptor, timeout thuận tiện, cấu hình client dùng lại Thêm dependency; lỗi HTTP được xử lý khác Fetch
child_process + cURL Di chuyển shell script, dùng tính năng cURL đặc thù Phụ thuộc binary; có rủi ro shell injection nếu ghép chuỗi
node-libcurl Cần khả năng libcurl cấp thấp Native addon, cài đặt và CI phức tạp hơn

Nếu chưa có yêu cầu đặc biệt, hãy bắt đầu bằng Fetch. Axios hợp lý khi dự án đã dùng thư viện này hoặc cần interceptor, cấu hình mặc định và cách xử lý response thống nhất.

Bảng chuyển tham số cURL sang JavaScript

cURL Fetch/Axios tương ứng
URL cuối lệnh Đối số URL của fetch() hoặc axios()
-X, --request method
-H, --header headers
-d, --data body trong Fetch, data trong Axios
-u, --user Header Authorization hoặc tùy chọn auth
--max-time AbortSignal hoặc timeout
-L, --location Redirect policy; Fetch thường follow redirect theo mặc định
-F, --form FormData
-x, --proxy Proxy agent/dispatcher hoặc cấu hình proxy của HTTP client

Việc chuyển đổi là ánh xạ từng phần, không phải đổi cú pháp bằng tìm và thay thế. Một số hành vi của browser, Node.js và cURL khác nhau, đặc biệt ở CORS, cookie, TLS, redirect và proxy.

Chuyển cURL GET sang Fetch

Lệnh cURL GET cơ bản:

curl "https://api.example.com/products?limit=10" \
  -H "Accept: application/json"

JavaScript:

async function getProducts() {
  const response = await fetch(
    'https://api.example.com/products?limit=10',
    {
      headers: {
        Accept: 'application/json',
      },
    },
  );

  if (!response.ok) {
    throw new Error(`Request thất bại: HTTP ${response.status}`);
  }

  return response.json();
}

const products = await getProducts();
console.log(products);

GET là method mặc định của Fetch nên không bắt buộc ghi method: 'GET'. Khi tạo query động, nên dùng URL và URLSearchParams thay vì ghép chuỗi thủ công:

const url = new URL('https://api.example.com/products');
url.searchParams.set('limit', '10');
url.searchParams.set('category', 'book');

const response = await fetch(url);

Cách này tự mã hóa khoảng trắng và ký tự đặc biệt trong query parameter.

Chuyển cURL POST JSON sang Fetch

Lệnh cURL:

curl https://api.example.com/posts \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"title":"Bài viết mới","published":false}'

Fetch:

async function createPost() {
  const response = await fetch('https://api.example.com/posts', {
    method: 'POST',
    headers: {
      Accept: 'application/json',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      title: 'Bài viết mới',
      published: false,
    }),
  });

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`HTTP ${response.status}: ${errorBody}`);
  }

  return response.json();
}

Fetch không tự chuyển object thành JSON. Bạn cần JSON.stringify() và đặt Content-Type: application/json. Nếu API trả body rỗng, gọi response.json() sẽ lỗi; hãy kiểm tra status hoặc content type trước khi parse.

Chuyển cURL sang Axios

Cài Axios:

npm install axios

GET request:

import axios from 'axios';

const response = await axios.get('https://api.example.com/products', {
  params: {
    limit: 10,
    category: 'book',
  },
  headers: {
    Accept: 'application/json',
  },
  timeout: 10_000,
});

console.log(response.data);

POST JSON:

import axios from 'axios';

const response = await axios.post(
  'https://api.example.com/posts',
  {
    title: 'Bài viết mới',
    published: false,
  },
  {
    headers: {
      Accept: 'application/json',
      'Content-Type': 'application/json',
    },
    timeout: 10_000,
  },
);

console.log(response.data);

Axios tự serialize object JSON trong trường hợp phù hợp và tự parse response JSON. Theo mặc định, Axios reject Promise với status ngoài khoảng thành công; Fetch thì không.

Xử lý header và xác thực

Bearer token

cURL:

curl https://api.example.com/me \
  -H "Authorization: Bearer YOUR_TOKEN"

Fetch:

const token = process.env.API_TOKEN;

const response = await fetch('https://api.example.com/me', {
  headers: {
    Authorization: `Bearer ${token}`,
    Accept: 'application/json',
  },
});

Không viết token thật trực tiếp trong source. Với frontend, biến môi trường được bundle vào JavaScript vẫn có thể bị người dùng xem; secret phải nằm ở backend. Chỉ các khóa được thiết kế công khai mới nên xuất hiện trong mã phía trình duyệt.

Basic Authentication

Trong Node.js, có thể tạo header Basic Auth:

const credentials = Buffer.from(
  `${process.env.API_USER}:${process.env.API_PASSWORD}`,
).toString('base64');

const response = await fetch('https://api.example.com/private', {
  headers: {
    Authorization: `Basic ${credentials}`,
  },
});

Base64 không phải mã hóa bảo mật. Luôn dùng HTTPS để bảo vệ credentials trên đường truyền.

Gửi form URL-encoded

cURL:

curl https://api.example.com/token \
  -X POST \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "grant_type=client_credentials" \
  --data-urlencode "scope=read:data"

Fetch:

const body = new URLSearchParams({
  grant_type: 'client_credentials',
  scope: 'read:data',
});

const response = await fetch('https://api.example.com/token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body,
});

URLSearchParams xử lý việc mã hóa giá trị, tránh lỗi khi dữ liệu chứa khoảng trắng hoặc ký tự đặc biệt.

Gửi multipart/form-data và file

Trong browser, tạo FormData rồi thêm file từ input:

const form = new FormData();
form.append('title', 'Tài liệu');
form.append('file', fileInput.files[0]);

const response = await fetch('https://api.example.com/upload', {
  method: 'POST',
  body: form,
});

Không tự đặt header Content-Type khi gửi FormData bằng Fetch. Trình duyệt cần tự thêm boundary chính xác. Trong Node.js, cách đọc file và tạo multipart phụ thuộc phiên bản runtime cùng loại object Blob/File được dùng; hãy tránh chuyển thẳng đường dẫn do người dùng cung cấp mà không kiểm tra.

Timeout trong Fetch bằng AbortSignal

cURL có --max-time; Fetch dùng cơ chế hủy request. Cách tương thích rõ ràng là AbortController:

async function fetchWithTimeout(url, options = {}, timeout = 10_000) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), timeout);

  try {
    return await fetch(url, {
      ...options,
      signal: controller.signal,
    });
  } finally {
    clearTimeout(timer);
  }
}

const response = await fetchWithTimeout(
  'https://api.example.com/data',
  {},
  10_000,
);

Axios có tùy chọn timeout trực tiếp:

const response = await axios.get('https://api.example.com/data', {
  timeout: 10_000,
});

Timeout chỉ giới hạn thời gian chờ. Nếu muốn retry, cần xác định request nào an toàn để lặp lại, đặt số lần tối đa và dùng backoff. Không retry vô hạn hoặc tự động lặp POST có tác dụng ghi dữ liệu.

Xử lý lỗi Fetch đúng cách

Fetch chỉ reject Promise khi gặp lỗi mạng, bị hủy hoặc lỗi tương tự. HTTP 404, 403 hay 500 vẫn tạo một Response, vì máy chủ đã phản hồi.

async function getJson(url) {
  let response;

  try {
    response = await fetchWithTimeout(url, {}, 10_000);
  } catch (error) {
    if (error.name === 'AbortError') {
      throw new Error('Request đã vượt quá thời gian chờ');
    }

    throw new Error(`Lỗi mạng: ${error.message}`);
  }

  if (!response.ok) {
    const body = await response.text();
    throw new Error(`HTTP ${response.status}: ${body.slice(0, 300)}`);
  }

  return response.json();
}

Không nên ghi toàn bộ response lỗi vào log nếu body có token, thông tin cá nhân hoặc dữ liệu nhạy cảm. Chỉ lưu phần cần thiết và áp dụng cơ chế che dữ liệu.

Xử lý lỗi Axios

import axios from 'axios';

try {
  const response = await axios.get('https://api.example.com/data', {
    timeout: 10_000,
  });

  console.log(response.data);
} catch (error) {
  if (axios.isAxiosError(error)) {
    if (error.response) {
      console.error('HTTP status:', error.response.status);
    } else if (error.request) {
      console.error('Không nhận được phản hồi');
    } else {
      console.error('Lỗi cấu hình request:', error.message);
    }
  } else {
    throw error;
  }
}

Phân biệt lỗi HTTP, không có response và lỗi cấu hình giúp quyết định có nên retry hay không. Đổi proxy hoặc tăng timeout không sửa được URL sai, token hết hạn hoặc request body không hợp lệ.

CORS: Vì sao cURL chạy nhưng Fetch trên browser lại lỗi?

cURL không chịu chính sách Same-Origin của trình duyệt. JavaScript frontend thì có. Khi trang web gọi API ở origin khác, máy chủ API phải trả header CORS phù hợp. Một request cURL chạy thành công không chứng minh request Fetch từ browser cũng được phép.

Không có cách hợp lệ để frontend tự “tắt CORS” của người dùng. Giải pháp đúng là:

  • Cấu hình CORS trên API nếu bạn quản lý máy chủ.

  • Gọi API từ backend của chính ứng dụng.

  • Dùng reverse proxy do bạn kiểm soát với danh sách đích được cho phép.

Không nên xây proxy backend nhận URL tùy ý rồi fetch mọi địa chỉ, vì có thể tạo lỗ hổng SSRF cho phép truy cập dịch vụ nội bộ hoặc metadata server.

Chạy binary cURL thật từ Node.js

Node.js có module child_process. Khi cần tái sử dụng một lệnh cURL hiện có, nên truyền từng tham số bằng execFile() hoặc spawn() thay vì nối chuỗi cho shell.

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

const execFileAsync = promisify(execFile);

const args = [
  '--silent',
  '--show-error',
  '--fail-with-body',
  '--header',
  'Accept: application/json',
  'https://api.example.com/posts/1',
];

const { stdout } = await execFileAsync('curl', args, {
  timeout: 10_000,
  maxBuffer: 1024 * 1024,
});

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

execFile() không mở shell theo mặc định, giúp giảm rủi ro shell injection so với exec() khi argument có dữ liệu động. Bạn vẫn phải kiểm tra URL, giới hạn thời gian, kích thước output và không cho người dùng tùy ý truyền cờ cURL.

Vì sao không nên ghép chuỗi bằng exec()?

Đoạn code sau nguy hiểm nếu userUrl đến từ input không tin cậy:

// Không nên dùng với dữ liệu động
exec(`curl "${userUrl}"`);

Ký tự shell trong input có thể làm thay đổi lệnh được thực thi. Hãy dùng execFile('curl', [userUrl]), đồng thời chỉ cho phép protocol, hostname và port nằm trong chính sách của ứng dụng.

Hạn chế của phương án child process

Máy chạy Node.js phải có binary cURL. Việc mock trong test phức tạp hơn HTTP client, output thường là chuỗi và lỗi status cần cờ bổ sung. Các hàm đồng bộ như execFileSync() còn chặn event loop, không phù hợp với server xử lý nhiều request.

Vì vậy, gọi cURL trực tiếp phù hợp với script di chuyển tạm thời hoặc tính năng cURL đặc thù; Fetch/Axios phù hợp hơn với code ứng dụng lâu dài.

Cấu hình proxy khi chuyển cURL sang JavaScript

cURL dùng cờ -x hoặc --proxy:

curl -x http://USERNAME:PASSWORD@HOST:PORT \
  https://httpbin.org/ip

Trong JavaScript, cách cấu hình phụ thuộc runtime và HTTP client. Browser Fetch không cho website tự chọn proxy mạng cho từng request. Proxy thường được cấu hình ở trình duyệt, hệ điều hành hoặc backend.

Axios trên Node.js hỗ trợ HTTP proxy qua cấu hình client:

import axios from 'axios';

const response = await axios.get('https://httpbin.org/ip', {
  proxy: {
    protocol: 'http',
    host: process.env.PROXY_HOST,
    port: Number(process.env.PROXY_PORT),
    auth: {
      username: process.env.PROXY_USERNAME,
      password: process.env.PROXY_PASSWORD,
    },
  },
  timeout: 10_000,
});

console.log(response.data);

Không đưa username/password vào frontend. Khi dùng Fetch trên Node.js, proxy thường được cấu hình qua dispatcher/agent tương thích với runtime; API cụ thể có thể thay đổi theo phiên bản nên cần đọc tài liệu Node.js hoặc HTTP client đang dùng.

Trước khi tích hợp, bạn nên hiểu proxy là gì, cách SOCKS Proxy hoạt động và các công dụng của proxy. Có thể dùng Proxy Checker để xác minh endpoint trước khi cho rằng code JavaScript bị lỗi.

Proxy miễn phí chỉ nên dùng cho thử nghiệm không chứa dữ liệu nhạy cảm. Endpoint công khai có thể chậm, hết hạn hoặc do đơn vị không rõ ràng vận hành. Các sản phẩm và hướng dẫn khác được tổng hợp trên Proxify.

Cookie và session: khác biệt giữa cURL, browser và Node.js

Browser Fetch quản lý cookie theo chính sách của trình duyệt. Khi gọi cross-origin, bạn có thể cần credentials: 'include', đồng thời server phải cho phép credentials qua CORS.

const response = await fetch('https://api.example.com/account', {
  credentials: 'include',
});

Fetch trong Node.js không cung cấp cookie jar tự động giống trình duyệt. Nếu workflow cần lưu cookie giữa nhiều request, hãy dùng thư viện cookie jar phù hợp hoặc HTTP client có tích hợp rõ ràng. Không tự ghi cookie nhạy cảm vào log.

Redirect và response body

Fetch thường theo redirect mặc định. Có thể đặt redirect: 'manual' hoặc 'error' khi cần kiểm soát. Lưu ý browser có thể hạn chế thông tin redirect cross-origin.

Response body là stream và thường chỉ đọc được một lần. Sau khi gọi response.json(), không thể tiếp tục gọi response.text() trên cùng body trừ khi clone response trước. Chọn cách parse dựa trên Content-Type:

const contentType = response.headers.get('content-type') || '';

const data = contentType.includes('application/json')
  ? await response.json()
  : await response.text();

Thực hành bảo mật khi dùng cURL trong JavaScript

Không đưa secret vào source hoặc ảnh chụp

Token, cookie và mật khẩu proxy phải nằm trong biến môi trường hoặc secret manager phía backend. Khi chia sẻ lệnh cURL từ DevTools, hãy xóa Authorization, Cookie và dữ liệu cá nhân.

Không chạy lệnh cURL không tin cậy

Một lệnh được sao chép từ Internet có thể ghi file, gửi dữ liệu hoặc dùng cờ ngoài dự kiến. Hãy đọc URL, method, header, body, output path và mọi pipeline trước khi chạy.

Chống SSRF trên backend

Nếu API của bạn nhận URL rồi fetch, hãy dùng allowlist hostname, chặn địa chỉ private/link-local, giới hạn redirect, protocol, port, kích thước response và timeout. Kiểm tra chỉ ở đầu vào chưa đủ vì DNS và redirect có thể thay đổi đích cuối.

Giới hạn response và thời gian

Request không giới hạn có thể tiêu thụ bộ nhớ hoặc giữ kết nối quá lâu. Đặt timeout, giới hạn body, concurrency và số lần retry.

Kiểm tra TLS thay vì tắt xác minh

Không chuyển cờ -k/--insecure sang code production để bỏ qua lỗi chứng chỉ. Hãy sửa certificate, CA hoặc hostname. Tắt xác minh TLS làm mất một lớp bảo vệ quan trọng.

Những lỗi thường gặp khi chuyển cURL sang JavaScript

Quên JSON.stringify() trong Fetch

Fetch không tự chuyển object thành JSON. Nếu API yêu cầu JSON, body phải là chuỗi JSON và header Content-Type cần đúng.

Không kiểm tra response.ok

Fetch không tự throw với 404 hoặc 500. Nếu bỏ qua kiểm tra, code có thể parse trang lỗi HTML như JSON.

Đưa header bị browser kiểm soát

Một số header không thể được frontend JavaScript tự đặt. Hãy để trình duyệt quản lý hoặc chuyển request xuống backend nếu thật sự cần quyền kiểm soát thấp hơn.

Nghĩ rằng lỗi CORS là lỗi cú pháp

Cùng một request chạy trong cURL nhưng lỗi trong browser thường liên quan chính sách origin. Cần sửa cấu hình server, không phải thêm header tùy ý ở client.

Ghép input vào lệnh shell

exec('curl ' + input) tạo nguy cơ shell injection. Dùng Fetch/Axios hoặc execFile() với mảng argument và kiểm tra URL.

Đặt proxy trong frontend

Frontend không nên chứa credentials proxy và không thể chọn proxy tùy ý cho từng Fetch request. Hãy cấu hình proxy ở backend hoặc hạ tầng mạng.

Checklist chuyển cURL sang JavaScript

  1. Xác định code chạy trong browser hay Node.js.

  2. Chọn Fetch cho giải pháp native hoặc Axios khi cần client nhiều tiện ích.

  3. Chuyển URL, method, headers và body từng phần.

  4. Dùng URLSearchParams, FormData hoặc JSON.stringify() đúng content type.

  5. Kiểm tra response.ok khi dùng Fetch.

  6. Đặt timeout và giới hạn retry.

  7. Xử lý CORS ở server hoặc backend.

  8. Không để secret trong source hay frontend bundle.

  9. Dùng execFile()/spawn() thay vì ghép chuỗi shell nếu phải gọi cURL.

  10. Kiểm tra proxy, TLS, redirect và kích thước response trước production.

Câu hỏi thường gặp

Có thể chạy cURL trực tiếp trong browser JavaScript không?

Không. Mã JavaScript trong browser không được chạy chương trình hệ điều hành. Hãy chuyển request sang Fetch hoặc gọi backend do bạn kiểm soát.

Fetch có phải cURL của JavaScript không?

Fetch là lựa chọn gần nhất cho request HTTP trong JavaScript, nhưng không thay thế toàn bộ tính năng cURL. Hai công cụ khác nhau ở CORS, protocol, cookie, TLS và proxy.

Node.js có sẵn Fetch không?

Node.js hiện đại cung cấp fetch() toàn cục. Với dự án cũ, cần nâng cấp runtime hoặc dùng HTTP client khác. Hãy kiểm tra phiên bản Node.js đang triển khai thay vì chỉ kiểm tra máy phát triển.

Fetch và Axios khác nhau điểm nào?

Fetch là Web API native và không tự throw với HTTP error. Axios là package bên ngoài, tự parse JSON trong nhiều trường hợp, hỗ trợ timeout và interceptor thuận tiện, đồng thời reject status ngoài phạm vi thành công theo cấu hình mặc định.

Làm sao chuyển cURL có -d sang JavaScript?

Xác định content type. Với JSON, dùng body: JSON.stringify(object) trong Fetch hoặc truyền object vào axios.post(). Với form URL-encoded, dùng URLSearchParams; với multipart, dùng FormData.

Vì sao Fetch không dùng được proxy giống curl -x?

Browser không cho website chọn proxy mạng cho từng request. Trong Node.js, cần cấu hình agent/dispatcher hoặc HTTP client hỗ trợ proxy. Không đặt credentials proxy trong mã frontend.

Có nên gọi cURL bằng child_process.exec() không?

Chỉ nên cân nhắc cho script kiểm soát hoàn toàn input. Với dữ liệu động, ưu tiên execFile() hoặc spawn() cùng mảng argument để giảm rủi ro shell injection. Code ứng dụng thông thường nên dùng Fetch hoặc Axios.

Kết luận

Để dùng cURL trong JavaScript, lựa chọn tốt nhất thường là chuyển request sang Fetch hoặc Axios. Hãy ánh xạ URL, method, headers, body và timeout theo từng phần; đồng thời nhớ rằng Fetch không tự báo lỗi với HTTP 4xx/5xx và browser chịu giới hạn CORS.

Node.js có thể gọi binary cURL qua child_process, nhưng phương án này phụ thuộc môi trường và cần kiểm soát chặt input. Với hầu hết dự án, HTTP client native hoặc thư viện JavaScript giúp code dễ kiểm thử, bảo trì và triển khai hơn. Khi request đi qua proxy, hãy cấu hình ở backend, bảo vệ credentials và xác minh endpoint trước khi xử lý lỗi ở tầng ứng dụng.

© 2026 Proxify.vn. All rights reserved.

Bảo mật · An toàn · Tự động