Nsryjdtyk

Try using the simple http.get(options, callback) function in node.js:

var http = require('http');

var options = {

  host: 'www.google.com',

  path: '/index.html'

};



var req = http.get(options, function(res) {

  console.log('STATUS: ' + res.statusCode);

  console.log('HEADERS: ' + JSON.stringify(res.headers));



  // Buffer the body entirely for processing as a whole.

  var bodyChunks = ;

  res.on('data', function(chunk) {

    // You can process streamed parts here...

    bodyChunks.push(chunk);

  }).on('end', function() {

    var body = Buffer.concat(bodyChunks);

    console.log('BODY: ' + body);

    // ...and/or process the entire body here.

  })

});



req.on('error', function(e) {

  console.log('ERROR: ' + e.message);

});

There is also a general http.request(options, callback) function which allows you to specify the request method and other request details.

Request and Superagent are pretty good libraries to use.

Using request:

var request=require('request');



request.get('https://someplace',options,function(err,res,body){

  if(err) //TODO: handle err

  if(res.statusCode !== 200 ) //etc

  //TODO Do something with response

});

You can also use Requestify, a really cool and very simple HTTP client I wrote for nodeJS + it supports caching.

Just do the following for GET method request:

var requestify = require('requestify');



requestify.get('http://example.com/api/resource')

  .then(function(response) {

      // Get the response body (JSON parsed or jQuery object for XMLs)

      response.getBody();

  }

);

Unirest is the best library I've come across for making HTTP requests from Node. It's aiming at being a multiplatform framework, so learning how it works on Node will serve you well if you need to use an HTTP client on Ruby, PHP, Java, Python, Objective C, .Net or Windows 8 as well. As far as I can tell the unirest libraries are mostly backed by existing HTTP clients (e.g. on Java, the Apache HTTP client, on Node, Mikeal's Request libary) - Unirest just puts a nicer API on top.

Here are a couple of code examples for Node.js:

var unirest = require('unirest')



// GET a resource

unirest.get('http://httpbin.org/get')

  .query({'foo': 'bar'})

  .query({'stack': 'overflow'})

  .end(function(res) {

    if (res.error) {

      console.log('GET error', res.error)

    } else {

      console.log('GET response', res.body)

    }

  })



// POST a form with an attached file

unirest.post('http://httpbin.org/post')

  .field('foo', 'bar')

  .field('stack', 'overflow')

  .attach('myfile', 'examples.js')

  .end(function(res) {

    if (res.error) {

      console.log('POST error', res.error)

    } else {

      console.log('POST response', res.body)

    }

  })

You can jump straight to the Node docs here

Check out shred. It's a node HTTP client created and maintained by spire.io that handles redirects, sessions, and JSON responses. It's great for interacting with rest APIs. See this blog post for more details.

Check out httpreq: it's a node library I created because I was frustrated there was no simple http GET or POST module out there ;-)

This version is based on the initially proposed by bryanmac function which uses promises, better error handling, and is rewritten in ES6.

let http = require("http"),

    https = require("https");



/**

 * getJSON:  REST get request returning JSON object(s)

 * @param options: http options object

 */

exports.getJSON = function(options)

{

    console.log('rest::getJSON');

    let reqHandler = +options.port === 443 ? https : http;



    return new Promise((resolve, reject) => {

        let req = reqHandler.request(options, (res) =>

        {

            let output = '';

            console.log('rest::', options.host + ':' + res.statusCode);

            res.setEncoding('utf8');



            res.on('data', function (chunk) {

                output += chunk;

            });



            res.on('end', () => {

                try {

                    let obj = JSON.parse(output);

                    // console.log('rest::', obj);

                    resolve({

                        statusCode: res.statusCode,

                        data: obj

                    });

                }

                catch(err) {

                    console.error('rest::end', err);

                    reject(err);

                }

            });

        });



        req.on('error', (err) => {

            console.error('rest::request', err);

            reject(err);

        });



        req.end();

    });

};

As a result you don't have to pass in a callback function, instead getJSON() returns a promise. In the following example the function is used inside of an ExpressJS route handler

router.get('/:id', (req, res, next) => {

    rest.getJSON({

        host: host,

        path: `/posts/${req.params.id}`,

        method: 'GET'

    }).then(({status, data}) => {

        res.json(data);

    }, (error) => {

        next(error);

    });

});

On error it delegates the error to the server error handling middleware.

If you just need to make simple get requests and don't need support for any other HTTP methods take a look at: simple-get:

var get = require('simple-get');



get('http://example.com', function (err, res) {

  if (err) throw err;

  console.log(res.statusCode); // 200

  res.pipe(process.stdout); // `res` is a stream

});

Look at request module. Reference here http://www.sitepoint.com/making-http-requests-in-node-js/

Use reqclient: not designed for scripting purpose
like request or many other libraries. Reqclient allows in the constructor
specify many configurations useful when you need to reuse the same
configuration again and again: base URL, headers, auth options,
logging options, caching, etc. Also has useful features like
query and URL parsing, automatic query encoding and JSON parsing, etc.

The best way to use the library is create a module to export the object
pointing to the API and the necessary configurations to connect with:

Module client.js:

let RequestClient = require("reqclient").RequestClient



let client = new RequestClient({

  baseUrl: "https://myapp.com/api/v1",

  cache: true,

  auth: {user: "admin", pass: "secret"}

})



module.exports = client

And in the controllers where you need to consume the API use like this:

let client = require('client')

//let router = ...



router.get('/dashboard', (req, res) => {

  // Simple GET with Promise handling to https://myapp.com/api/v1/reports/clients

  client.get("reports/clients")

    .then(response => {

       console.log("Report for client", response.userId)  // REST responses are parsed as JSON objects

       res.render('clients/dashboard', {title: 'Customer Report', report: response})

    })

    .catch(err => {

      console.error("Ups!", err)

      res.status(400).render('error', {error: err})

    })

})



router.get('/orders', (req, res, next) => {

  // GET with query (https://myapp.com/api/v1/orders?state=open&limit=10)

  client.get({"uri": "orders", "query": {"state": "open", "limit": 10}})

    .then(orders => {

      res.render('clients/orders', {title: 'Customer Orders', orders: orders})

    })

    .catch(err => someErrorHandler(req, res, next))

})



router.delete('/orders', (req, res, next) => {

  // DELETE with params (https://myapp.com/api/v1/orders/1234/A987)

  client.delete({

    "uri": "orders/{client}/{id}",

    "params": {"client": "A987", "id": 1234}

  })

  .then(resp => res.status(204))

  .catch(err => someErrorHandler(req, res, next))

})

reqclient supports many features, but it has some that are not supported by other
libraries: OAuth2 integration and logger integration
with cURL syntax, and always returns native Promise objects.

## you can use request module and promise in express to make any request ##

const promise                       = require('promise');

const requestModule                 = require('request');



const curlRequest =(requestOption) =>{

    return new Promise((resolve, reject)=> {

        requestModule(requestOption, (error, response, body) => {

            try {

                if (error) {

                    throw error;

                }

                if (body) {



                    try {

                        body = (body) ? JSON.parse(body) : body;

                        resolve(body);

                    }catch(error){

                        resolve(body);

                    }



                } else {



                    throw new Error('something wrong');

                }

            } catch (error) {



                reject(error);

            }

        })

    })

};



const option = {

    url : uri,

    method : "GET",

    headers : {



    }

};





curlRequest(option).then((data)=>{

}).catch((err)=>{

})