Skip to content

Instantly share code, notes, and snippets.

@sviatco
Last active Aug 19, 2021
Embed
What would you like to do?
Get local external ip address with nodejs
var
// Local ip address that we're trying to calculate
address
// Provides a few basic operating-system related utility functions (built-in)
,os = require('os')
// Network interfaces
,ifaces = os.networkInterfaces();
// Iterate over interfaces ...
for (var dev in ifaces) {
// ... and find the one that matches the criteria
var iface = ifaces[dev].filter(function(details) {
return details.family === 'IPv4' && details.internal === false;
});
if(iface.length > 0) address = iface[0].address;
}
// Print the result
console.log(address);
@guatedude2
Copy link

guatedude2 commented May 26, 2016

A nice compact version of this:

// Network interfaces
var ifaces = require('os').networkInterfaces();

// Iterate over interfaces ...
var adresses = Object.keys(ifaces).reduce(function (result, dev) {
  return result.concat(ifaces[dev].reduce(function (result, details) {
    return result.concat(details.family === 'IPv4' && !details.internal ? [details.address] : []);
  }, []));
});

// Print the result
console.log(adresses)

@gabemeola
Copy link

gabemeola commented Jun 25, 2016

Alt Condense Way

var address,
    ifaces = require('os').networkInterfaces();
for (var dev in ifaces) {
    ifaces[dev].filter((details) => details.family === 'IPv4' && details.internal === false ? address = details.address: undefined);
}

console.log(address);

@mimosa
Copy link

mimosa commented Aug 9, 2017

ES6

  const ifaces = require('os').networkInterfaces();
  let address;

  Object.keys(ifaces).forEach(dev => {
    ifaces[dev].filter(details => {
      if (details.family === 'IPv4' && details.internal === false) {
        address = details.address;
      }
    });
  });

@konsumer
Copy link

konsumer commented Sep 6, 2017

moar condense ES6

// commonjs: const networkInterfaces = require('os').networkInterfaces
import { networkInterfaces } from 'os'

const getLocalExternalIp = () => [].concat.apply([], Object.values(networkInterfaces()))
  .filter(details => details.family === 'IPv4' && !details.internal)
  .pop().address

@DrJume
Copy link

DrJume commented Mar 4, 2018

This even more condensed ES6 code seems to work

// commonjs: const { networkInterfaces } = require('os')
import { networkInterfaces } from 'os'

const getLocalExternalIP = () => [].concat(...Object.values(networkInterfaces()))
  .filter(details => details.family === 'IPv4' && !details.internal)
  .pop().address

@bluefangs
Copy link

bluefangs commented Apr 6, 2018

I hate to be the condense-code combobreaker, but I have a question. Suppose there are a few interfaces and some of them have IP addresses assigned to them, how do I extract the IP of the currently connected interface?

As an example, I have the below interfaces: wlx20e01600b682, vmnet1, vmnet2, etc.

wlx20e01600b682 looks like:

 { address: '192.168.1.70',
    netmask: '255.255.255.0',
    family: 'IPv4',
    mac: '20:e0:16:00:b6:82',
    internal: false } 


Now, my desktop is actually connected to wlx20e01600b682. In the above approaches, I either get an array of all IPs or the first IP in the addresses array. Which sometimes is not the IP of the currently active interface. Is there a possibility to get that?

Something like how the npm 'ip' module does.

var ip = require('ip');
console.log(ip.address());

@tjbenton
Copy link

tjbenton commented Apr 29, 2020

I know this is an older gist but if you just use find it's shorter and faster because it doesn't go through all the items in the array and you don't need a the second function pop

import { networkInterfaces } from 'os'

const getLocalExternalIP = () => [].concat(...Object.values(networkInterfaces()))
  .find((details) => details.family === 'IPv4' && !details.internal)
  .address

@brokenthorn
Copy link

brokenthorn commented May 5, 2020

My TypeScript version of the functions to get internal and external IPv4 network interface infos (NInfos):

// commonjs: const { networkInterfaces } = require('os')
import { networkInterfaces, NetworkInterfaceInfo } from 'os';

/**
 * Returns an array of `NetworkInterfaceInfo`s for all host interfaces that
 * have IPv4 addresses from the private address space,
 * including the loopback address space (127.x.x.x).
 */
export const getPrivateIPNInfos = (): (NetworkInterfaceInfo | undefined)[] => {
  return Object.values(networkInterfaces())
    .flatMap((infos) => {
      return infos?.filter((i) => i.family === 'IPv4');
    })
    .filter((info) => {
      return (
        info?.address.match(
          /(^127\.)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^192\.168\.)/
        ) !== null
      );
    });
};

/**
 * Returns an array of IPv4 addresses for all host interfaces that
 * have IPv4 addresses from the private address space,
 * including the loopback address space (127.x.x.x).
 */
export const getPrivateIPs = (): (string | undefined)[] => {
  return getPrivateIPNInfos().map((i) => i?.address);
};


/**
 * Returns an array of `NetworkInterfaceInfo`s for all host interfaces that
 * have IPv4 addresses from the external private address space,
 * ie. except the loopback (internal) address space (127.x.x.x).
 */
export const getPrivateExternalIPNInfos = (): (
  | NetworkInterfaceInfo
  | undefined
)[] => {
  return Object.values(networkInterfaces())
    .flatMap((infos) => {
      return infos?.filter((i) => !i.internal && i.family === 'IPv4');
    })
    .filter((info) => {
      return (
        info?.address.match(
          /(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^192\.168\.)/
        ) !== null
      );
    });
};

/**
 * Returns an array of IPv4 addresses for all host interfaces that
 * have IPv4 addresses from the external private address space,
 * ie. except the loopback (internal) address space (127.x.x.x).
 */
export const getPrivateExternalIPs = (): (string | undefined)[] => {
  return getPrivateExternalIPNInfos().map((i) => i?.address);
};

Sample output:

[
  {
    address: '127.0.0.1',
    netmask: '255.0.0.0',
    family: 'IPv4',
    mac: '00:00:00:00:00:00',
    internal: true,
    cidr: '127.0.0.1/8'
  }
]
[
  {
    address: '192.168.88.176',
    netmask: '255.255.255.0',
    family: 'IPv4',
    mac: 'xx:xx:xx:xx:xx:xx',
    internal: false,
    cidr: '192.168.88.176/24'
  }
]

The other functions just return the addresses directly.

...Oh, yeah, the naming of the functions happened by accident, but I decided to keep them.

@ABXlink
Copy link

ABXlink commented Jan 31, 2021

Even more condensed with find and flat.

import { networkInterfaces } from 'os';

const ip = Object.values(networkInterfaces()).flat().find(i => i.family == 'IPv4' && !i.internal).address;

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment