you can easily use request module:
https://www.npmjs.com/package/request
Sample code:
var request = require('request');
request('http://www.google.com', function (error, response, body) {
if (!error && response.statusCode == 200) {
console.log(body) // Show the HTML for the Google homepage.
}
else {
console.log("Error "+response.statusCode)
}
})
Uses reqclient, it's a small client module on top of request that allows you to log all the activity with cURL style (optional, for development environments). Also has nice features like URL and parameters parsing, authentication integrations, cache support, etc.
For example, if you create a client object an do a request:
var RequestClient = require("reqclient").RequestClient;
var client = new RequestClient({
baseUrl:"http://baseurl.com/api/v1.1",
debugRequest:true, debugResponse:true
});
var resp = client.post("client/orders", {"client":1234,"ref_id":"A987"}, {headers: {"x-token":"AFF01XX"}})
It will log within the console something like this:
[Requesting client/orders]-> -X POST http://baseurl.com/api/v1.1/client/orders -d '{"client": 1234, "ref_id": "A987"}' -H '{"x-token": "AFF01XX"}' -H Content-Type:application/json
[Response client/orders]<- Status 200 - {"orderId": 1320934}
The request will return a Promise object, so you have to handle with then and catch what to do with the result.
reqclient is available with npm, you can install the module with: npm install reqclient.
For new projects please refrain from using request, since now the project is in maitainance mode, and will eventually be deprecated
https://github.com/request/request/issues/3142
Instead i would recommend Axios, the library is in line with Node latest standards, and there are some available plugins to enhance it, enabling mock server responses, automatic retries and other features.
https://github.com/axios/axios
const axios = require('axios');
// Make a request for a user with a given ID
axios.get('/user?ID=12345')
.then(function (response) {
// handle success
console.log(response);
})
.catch(function (error) {
// handle error
console.log(error);
})
.then(function () {
// always executed
});
Or using async / await:
try{
const response = await axios.get('/user?ID=12345');
console.log(response)
} catch(axiosErr){
console.log(axiosErr)
}
I usually use REQUEST, its a simplified but powerful HTTP client for Node.js
https://github.com/request/request
Its on NPM
npm install request
Here is a usage sample:
var request = require('request');
request('http://www.google.com', function (error, response, body) {
if (!error && response.statusCode == 200) {
console.log(body) // Show the HTML for the Google homepage.
}
})
There is npm module to make a curl like request, npm curlrequest.
Step 1: $npm i -S curlrequest
Step 2: In your node file
let curl = require('curlrequest')
let options = {} // url, method, data, timeout,data, etc can be passed as options
curl.request(options,(err,response)=>{
// err is the error returned from the api
// response contains the data returned from the api
})
For further reading and understanding, npm curlrequest
Here is a standard lib (http) async / await solution.
const http = require("http");
const fetch = async (url) => {
return new Promise((resolve, reject) => {
http
.get(url, (resp) => {
let data = "";
resp.on("data", (chunk) => {
data += chunk;
});
resp.on("end", () => {
resolve(data);
});
})
.on("error", (err) => {
reject(err);
});
});
};
Usage:
await fetch("http://example.com");
well if you really need a curl equivalent you can try node-curl
npm install node-curl
you will probably need to add libcurl4-gnutls-dev.
I had a problem sending POST data to cloud DB from IOT RaspberryPi, but after hours I managed to get it straight.
I used command prompt to do so.
sudo curl --URL http://<username>.cloudant.com/<database_name> --user <api_key>:<pass_key> -X POST -H "Content-Type:application/json" --data '{"id":"123","type":"987"}'
Command prompt will show the problems - wrong username/pass; bad request etc.
--URL database/server location (I used simple free Cloudant DB) --user is the authentication part username:pass I entered through API pass -X defines what command to call (PUT,GET,POST,DELETE) -H content type - Cloudant is about document database, where JSON is used --data content itself sorted as JSON
You can use request npm module . Super simple to use. Request is designed to be the simplest way possible to make http calls. It supports HTTPS and follows redirects by default.
var request = require('request');
request('http://www.google.com', function (error, response, body) {
console.log('error:', error); // Print the error if one occurred
console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
console.log('body:', body); // Print the HTML for the Google homepage.
});
Use request npm module and after call
var request = require('request');
request('http://www.google.com', function (error, response, body) {
console.log('error:', error); // Print the error if one occurred
console.log('statusCode:', response && response.statusCode); // Print the response status code if a response was received
console.log('body:', body); // Print the HTML for the Google homepage.
});
For best practice also use some winston logger module or else simple console.log and then run your application like
npm start output.txt
Result of above command will generate one txt file on root with all data which you have printed in console.log
You can try using POSTMAN Chrome app for your request and you can generate node js code from there
Request npm module Request node moulde is good to use, it have options settings for get/post request plus it is widely used in production environment too.
The above examples work but don't go so far as to really deal with a real world example (i.e. when you process data coming in multiple chunks. One thing you need to make sure of is that you have an 'on chunk' handler that push's the data into an array (fastest way to do this in JS) and an 'on end' handler that joins them all together so you can return it.
This is especially necessary when you're working with big requests (5000+ lines) and the server sends a bunch of data at you.
Here's an example in one of my programs (coffeescript): https://gist.github.com/1105888
Since looks like node-curl is dead, I've forked it, renamed, and modified to be more curl like and to compile under Windows.
Usage example:
var Curl = require( 'node-libcurl' ).Curl;
var curl = new Curl();
curl.setOpt( Curl.option.URL, 'www.google.com' );
curl.setOpt( 'FOLLOWLOCATION', true );
curl.on( 'end', function( statusCode, body, headers ) {
console.info( statusCode );
console.info( '---' );
console.info( body.length );
console.info( '---' );
console.info( headers );
console.info( '---' );
console.info( this.getInfo( Curl.info.TOTAL_TIME ) );
this.close();
});
curl.on( 'error', function( err, curlErrorCode ) {
console.error( err.message );
console.error( '---' );
console.error( curlErrorCode );
this.close();
});
curl.perform();
Perform is async, and there is no way to use it synchronous currently (and probably will never have).
It's still in alpha, but this is going to change soon, and help is appreciated.
Now it's possible to use Easy handle directly for sync requests, example:
var Easy = require( 'node-libcurl' ).Easy,
Curl = require( 'node-libcurl' ).Curl,
url = process.argv[2] || 'http://www.google.com',
ret, ch;
ch = new Easy();
ch.setOpt( Curl.option.URL, url );
ch.setOpt( Curl.option.HEADERFUNCTION, function( buf, size, nmemb ) {
console.log( buf );
return size * nmemb;
});
ch.setOpt( Curl.option.WRITEFUNCTION, function( buf, size, nmemb ) {
console.log( arguments );
return size * nmemb;
});
// this call is sync!
ret = ch.perform();
ch.close();
console.log( ret, ret == Curl.code.CURLE_OK, Easy.strError( ret ) );
Also, the project is stable now!
How about for example https://github.com/joyent/node/wiki/modules#wiki-tcp. A very quick summary =>
The http module that you use to run servers is also used to make remote requests.
Here's the example in their docs:
var http = require("http");
var options = {
host: 'www.google.com',
port: 80,
path: '/upload',
method: 'POST'
};
var req = http.request(options, function(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
res.on('data', function (chunk) {
console.log('BODY: ' + chunk);
});
});
req.on('error', function(e) {
console.log('problem with request: ' + e.message);
});
// write data to request body
req.write('data\n');
req.write('data\n');
req.end();
You might want to try using something like this
curl = require('node-curl');
curl('www.google.com', function(err) {
console.info(this.status);
console.info('-----');
console.info(this.body);
console.info('-----');
console.info(this.info('SIZE_DOWNLOAD'));
});
I ended up using the grunt-shell library.
Here is my source gist for my fully implemented Grunt task for anyone else thinking about working with the EdgeCast API. You'll find in my example that I use a grunt-shell to execute the curl command which purges the CDN.
This was that I ended up with after spending hours trying to get an HTTP request to work within Node. I was able to get one working in Ruby and Python, but did not meet the requirements of this project.
Source: Stackoverflow.com