DEV Community: IP2Location

How to use IP2Location.io API in Anaconda Code

IP2Location — Wed, 03 Dec 2025 09:32:03 +0000

Intro

Anaconda Code is an Excel add-in that enables users to execute Python or R code directly within Excel. It allows you to create custom Python functions for use in Excel workbooks. In addition, its package management support makes it easy to add or remove packages, significantly extending Excel’s capabilities. With these features, tasks such as querying external APIs for data become possible right inside Excel.

In this tutorial, we will guide you through using Anaconda Code to query the IP2Location.io API and display the results in your workbook. The IP2Location.io service provides a fast and accurate IP geolocation API that allows users to determine a visitor’s geographical location and apply geolocation data in various use cases.

Before we begin, please ensure that Anaconda Code is installed in your Excel application. It can be installed by adding the Anaconda Toolbox Excel add-in. You may refer to their installation guide for detailed steps.

In addition, to make a CORS request to the IP2Location.io API, you will need an active subscription. CORS support is available only for the Starter plan and above. You may view and purchase a plan here: https://www.ip2location.io/pricing

Steps to Use the IP2Location.io API in Anaconda Code

Step 1:
In Excel, go to the Formulas tab and click the Code icon.

Step 2：
Click the Sign In button, and click it again to proceed.

Step 3:
By default, Anaconda Code requires you to sign in before use. Then, log in using your Anaconda account or sign in with Google, Microsoft, or GitHub.

Step 4:
If this is your first time using it, you will need to create an Anaconda Code cell. For this tutorial, we will use the default settings. Click Create Code Cell to continue.

Step 5:
Click the Imports and Definitions icon to import the necessary package. Enter the following to import the required library:

from pyodide.http import pyfetch

Step 6:
After that, scroll to the end of the Code tab and paste the provided code snippet:

async def iplio_query(ip: str, column: str | None = None):
    base_api = 'https://api.ip2location.io/?'
    api_key = 'YOUR_API_KEY'
    full_url = f'{base_api}key={api_key}&ip={ip}'
    resp = await pyfetch(full_url)
    data = await resp.json()
    print(type(data))
    if column is not None:
        print(f'column is {column}')
        response = data[column]
        return response
    return data

Note to the API:
You must upgrade to any paid plan to be able to use our API to bypass the CORS limitation.

Step 7:
Click Apply when you are done.

Step 8:
You can now use the custom function to query the IP2Location.io API for geolocation results. For example, if you have an IP address stored in cell A14, simply enter the following formula in any cell you prefer:

=ANACONDA.IPLIO_QUERY(A14)

Conclusion

In summary, Anaconda Code enhances Excel by enabling access to external data through Python or R. It is especially useful when you have a list of IP addresses stored in Excel and want to populate accurate geolocation information using a reliable API. In this tutorial, we have demonstrated how to query IP2Location.io, but you can use the same approach with any other API to achieve similar results.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation/Proxy Detection API?

Are you looking for free IP Geolocation/Proxy Detection database?

Check a list of IP addresses for proxies using IP2Proxy Dart

IP2Location — Fri, 03 Oct 2025 02:37:30 +0000

Intro

Dart is a client-optimized, object-oriented programming language developed by Google for building fast apps on multiple platforms, including mobile, desktop, web, and server-side applications. It is best known as the language behind Flutter, Google’s UI toolkit for creating cross-platform applications. Dart features C-style syntax, modern capabilities like null safety and async-await, and the ability to compile to different machine code and JavaScript targets.

In this article, we’ll show how to use the IP2Proxy Dart package in a Dart command line (CLI) project to easily query the IP2Proxy BIN files to retrieve proxy data for a list of IP addresses. Our example will be using Debian 13 so some of the steps will be specific for that platform.

Pre-requisites

First, install Dart if you don’t have it installed on your system. Refer to https://dart.dev/get-dart for the installation steps specific to your system. In addition to that, you’ll also need the IP2Proxy PX12 BIN database files, which contain the proxy detection data.

You can download the BIN files from the following sources:

Commercial BIN files (full data & accuracy): IP2Location
Free LITE BIN files (basic data): IP2Location LITE

💡 The commercial edition provides the most comprehensive and up-to-date proxy detection, while the LITE edition is a good starting point for testing or smaller projects.

Next, download the zipped file and extract the BIN file to a folder of your choosing. For our case, we are storing the BIN file path as /home/admin/data/IP2PROXY-PX12.BIN so that’s what we’ll use later.

Create a new Dart console project

Navigate to the folder where you want to create the new project. In our case, it’s dartarticle.

Next, run the below command to create an initial Dart console project.

dart create -t console ip2proxy_cli

Then, navigate to the newly created folder.

cd ip2proxy_cli

This creates a small CLI app with bin/ip2proxy_cli.dart as the entrypoint.

Include the IP2Proxy Dart as a dependency

Check for the latest version of the IP2Proxy Dart package and modify the code below for that version. We are also using the args package for specifying the command line parameters.

Edit the pubspec.yaml and add the below under the dependencies section:

ip2proxy: ^3.0.0
args: ^2.7.0

Save the file and run the command below to fetch the dependencies.

dart pub get

Implement the command line codes

Edit bin/ip2proxy_cli.dart and replace the existing codes with the codes below.

import 'dart:convert';
import 'dart:io';
import 'package:args/args.dart';
import 'package:ip2proxy/ip2proxy.dart';

Future<void> main(List<String> arguments) async {
  final parser = ArgParser()
    ..addOption('db', abbr: 'd', help: 'Path to IP2Proxy BIN database')
    ..addOption('input', abbr: 'i', help: 'Path to file containing IP addresses (or omit for stdin)');

  final results = parser.parse(arguments);

  final dbFile = results['db'] ?? 'IP2PROXY-LITE-PX1.BIN';
  final inputFile = results['input'] ?? '';

  final ipx = IP2Proxy(databasePath: dbFile);

  Stream<List<int>> inputStream;

  if (inputFile.isNotEmpty) {
    final file = File(inputFile);
    if (await file.exists()) {
      inputStream = file.openRead();
    } else {
      stderr.writeln('Error: File not found: $inputFile');
      exit(1);
    }
  } else {
    inputStream = stdin;
  }

  // Print CSV header (quoted)
  print([
    "ipAddress",
    "isProxy",
    "proxyType",
    "countryShort",
    "countryLong",
    "region",
    "city",
    "isp",
    "domain",
    "usageType",
    "asn",
    "as",
    "lastSeen",
    "threat",
    "provider",
    "fraudScore"
  ].map(_csvEscape).join(','));

  // Process line by line
  await for (final ip in inputStream.transform(utf8.decoder).transform(LineSplitter())) {
    final result = await ipx.getAll(ip.trim());
    print([
      result.ipAddress,
      result.isProxy,
      result.proxyType,
      result.countryShort,
      result.countryLong,
      result.region,
      result.city,
      result.isp,
      result.domain,
      result.usageType,
      result.asn,
      result.asName,
      result.lastSeen,
      result.threat,
      result.provider,
      result.fraudScore
    ].map((e) => _csvEscape(e.toString())).join(','));
  }
}

/// Escapes values for CSV (wraps in quotes if needed, doubles inner quotes)
String _csvEscape(String s) {
  // Always quote, even if not strictly required
  return '"${s.replaceAll('"', '""')}"';
}

User can optionally specify the location of the BIN file using the -d flag. If not specified, the code will look for IP2PROXY-LITE-PX1.BIN instead. Using the optional -i flag, user can make the code read IP addresses from a text file. In the input file, there should be 1 IP address per line. If the input file is not specified, the code will assume STDIN as the input.

Test the code

Let’s test the code and make sure everything is working.

Use the command below to test the code.

echo -e "8.8.8.8" | dart run bin/ip2proxy_cli.dart -d /home/admin/data/IP2PROXY-PX12.BIN

You’ll see the results below.

"ipAddress","isProxy","proxyType","countryShort","countryLong","region","city","isp","domain","usageType","asn","as","lastSeen","threat","provider","fraudScore"
"8.8.8.8","2","DCH","US","United States of America","California","Mountain View","Google LLC","google.com","DCH","15169","Google LLC","1","-","-","0"

Compile into executable binary

To make it easier to distribute to other Linux users, we can go an extra step and compile it into a native executable binary.

Run the below command in the root of your project folder to compile the code.

dart compile exe bin/ip2proxy_cli.dart -o ip2proxy_cli

Run the executable to get your proxy results

Run the executable to get your proxy data similar to our testing command, with just a slight difference. Let’s try piping 2 IP addresses to the program and see.

echo -e "8.8.8.8\n1.1.1.1" | ./ip2proxy_cli -d /home/admin/data/IP2PROXY-PX12.BIN

You should see the results below.

"ipAddress","isProxy","proxyType","countryShort","countryLong","region","city","isp","domain","usageType","asn","as","lastSeen","threat","provider","fraudScore"
"8.8.8.8","2","DCH","US","United States of America","California","Mountain View","Google LLC","google.com","DCH","15169","Google LLC","1","-","-","0"
"1.1.1.1","2","DCH","AU","Australia","Queensland","Brisbane","APNIC and CloudFlare DNS Resolver Project","cloudflare.com","CDN","13335","CloudFlare Inc","1","-","-","0"

Conclusion

We’ve shown a simple example above for piping in the IP address to query for the proxy data. The code above also supports reading the IP addresses from a text file using the -i flag when calling the executable. Give it a try for yourself and you’ll soon find this to be a useful tool to have for a quick check for proxy servers in your IP address list. This feature is especially handy for system administrators who need to analyze web server logs or other log files.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation/Proxy Detection API?

Are you looking for free IP Geolocation/Proxy Detection database?

Using IP2Location Dart in console project

IP2Location — Thu, 11 Sep 2025 04:55:01 +0000

Intro

Dart is a client-optimized, object-oriented programming language developed by Google for building fast apps on multiple platforms, including mobile, desktop, web, and server-side applications. It is best known as the language behind Flutter, Google's UI toolkit for creating cross-platform applications. Dart features C-style syntax, modern capabilities like null safety and async-await, and the ability to compile to different machine code and JavaScript targets.

In this article, we’ll show how to use the IP2Location Dart package in a Dart command line (CLI) project to easily query the IP2Location BIN files to retrieve geolocation data for an IPv4 or IPv6 address. Our example will be using Debian 13 so some of the steps will be specific for that platform.

Pre-requisites

First, install Dart if you don’t have it installed on your system. Refer to https://dart.dev/get-dart for the installation steps specific to your system. In addition to that, you’ll also need the IP2Location DB26 BIN database files that contains the geolocation data. You can download the IP2Location Commercial BIN files or the Free LITE BIN files.

Download the zipped file and extract the BIN file to a folder of your choosing. For our case, we are storing the BIN file path as /home/admin/data/IP2LOCATION-DB26.IPV6.BIN so that’s what we’ll use later.

Create a new Dart console project

Navigate to the folder where you want to create the new project. In our case, it’s dartarticle.

Next, run the below command to create an initial Dart console project.

dart create -t console ip2location_cli

Then, navigate to the newly created folder.

cd ip2location_cli

This creates a small CLI app with bin/ip2location_cli.dart as the entrypoint.

Include the IP2Location Dart as a dependency

Check for the latest version of the IP2Location Dart package and modify the code below for that version. We are also using the args package for specifying the command line parameters.

Edit the pubspec.yaml and add the below under the dependencies section:

ip2location: ^8.1.0
args: ^2.7.0

Save the file and run the command below to fetch the dependencies.

dart pub get

Implement the command line codes

Edit bin/ip2location_cli.dart and replace the existing codes with the codes below.

import 'dart:io';
import 'package:args/args.dart';
import 'package:ip2location/ip2location.dart';

void main(List<String> arguments) async {
  final parser = ArgParser()
    ..addOption('db', abbr: 'd', help: 'Path to IP2Location BIN database');
  final results = parser.parse(arguments);

  if (results.rest.isEmpty) {
    print('Usage: ip2location_cli <IP> -d <DB_PATH>');
    exit(1);
  }

  final ip = results.rest[0];
  final dbFile = results['db'] ?? 'IP2LOCATION-LITE-DB1.BIN';

  IP2Location ipl = IP2Location(databasePath: dbFile);

  try {
    final result = await ipl.getAll(ip);

    print('IP Address: ${ip}');
    print('countryShort: ${result.countryShort}');
    print('countryLong: ${result.countryLong}');
    print('region: ${result.region}');
    print('city: ${result.city}');
    print('isp: ${result.isp}');
    print('latitude: ${result.latitude?.toStringAsFixed(6)}');
    print('longitude: ${result.longitude?.toStringAsFixed(6)}');
    print('domain: ${result.domain}');
    print('zipCode: ${result.zipCode}');
    print('netSpeed: ${result.netSpeed}');
    print('timeZone: ${result.timeZone}');
    print('iddCode: ${result.iddCode}');
    print('areaCode: ${result.areaCode}');
    print('weatherStationCode: ${result.weatherStationCode}');
    print('weatherStationName: ${result.weatherStationName}');
    print('mcc: ${result.mcc}');
    print('mnc: ${result.mnc}');
    print('mobileBrand: ${result.mobileBrand}');
    print('elevation: ${result.elevation}');
    print('usageType: ${result.usageType}');
    print('addressType: ${result.addressType}');
    print('category: ${result.category}');
    print('district: ${result.district}');
    print('asn: ${result.asn}');
    print('asName: ${result.asName}');
    print('asDomain: ${result.asDomain}');
    print('asUsageType: ${result.asUsageType}');
    print('asCIDR: ${result.asCIDR}');
  } catch (e) {
    stderr.writeln('Error looking up IP: $e');
    exit(1);
  }
}

The code accepts the first parameter as the IP address to query for geolocation. User can also optionally specify the location of the BIN file using the -d flag. If not specified, the code will look for IP2LOCATION-LITE-DB1.BIN instead.

Test the code

Let’s test the code and make sure everything is working.

Use the command below to test the code.

dart run bin/ip2location_cli.dart 8.8.8.8 -d /home/admin/data/IP2LOCATION-DB26.IPV6.BIN

You’ll see the results below.

IP Address: 8.8.8.8 countryShort: US countryLong: United States of America region: California city: Mountain View isp: Google LLC latitude: 37.386051 longitude: -122.083847 domain: google.com zipCode: 94035 netSpeed: T1 timeZone: -07:00 iddCode: 1 areaCode: 650 weatherStationCode: USCA0746 weatherStationName: Mountain View mcc: - mnc: - mobileBrand: - elevation: 32.0 usageType: DCH addressType: A category: IAB19-11 district: Santa Clara County asn: 15169 asName: Google LLC asDomain: google.com asUsageType: DCH asCIDR: 8.8.8.0/24

Compile into executable binary

To make it easier to distribute to other Linux users, we can go an extra step and compile it into a native executable binary.

Run the below command in the root of your project folder to compile the code.

dart compile exe bin/ip2location_cli.dart -o ip2location_cli

Run the executable to get your geolocation results

Run the executable to get your geolocation similar to our testing command, with just a slight difference. You should see the same results.

./ip2location_cli 8.8.8.8 -d /home/admin/data/IP2LOCATION-DB26.IPV6.BIN

Conclusion

It is very straightforward to call the IP2Location Dart package in your code as we’ve shown above. So, no reason why you can’t include geolocation functionality into your Dart programs or apps. This will seriously enhance the functionality of your codes.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

Displaying User’s Local Time with DST Adjustment via IP2Location.io

IP2Location — Tue, 02 Sep 2025 02:17:41 +0000

Displaying local time correctly is crucial for both website owners and visitors. By showing the local time, including daylight saving adjustments on a website, visitors can understand date and time information accurately. This improves clarity for time-sensitive content and helps minimize potential confusion or misunderstandings.

Incorrect timezone usage can lead to various issues and inconveniences. For example, users might misinterpret important information such as delivery dates or the start and end times of a promotional event. Inaccurate timezone handling can also cause miscommunication. Imagine a scenario where one person is in the United States and another is in Japan, with an online meeting scheduled at 2:00 PM UTC+0. If either side misreads the time, they could end up missing the meeting entirely.

To help users identify the correct timezone and handle Daylight Saving Time (DST) effectively, IP2Location.io had recently introduced new fields in the API response, namely abbreviation, dst_start_date, and dst_end_date. These, combined with the existing timezone information, enable developers to manage datetime data across multiple regions effectively and effortlessly.

Using IP2Location.io to Get Timezone Info

To get the result that contains the new fields, you just need to call the API again, for example https://api.ip2location.io/?key={YOUR_API_KEY}&ip=8.8.8.8&format=json for the IP 8.8.8.8. You will see the output as below:

{
  "ip": "8.8.8.8",
  "country_code": "US",
  "country_name": "United States of America",
  "region_name": "California",
  "district": "Santa Clara County",
  "city_name": "Mountain View",
  "latitude": 37.38605,
  "longitude": -122.08385,
  "zip_code": "94035",
  "time_zone": "-07:00",
  "asn": "15169",
  "as": "Google LLC",
  "isp": "Google LLC",
  "domain": "google.com",
  "net_speed": "T1",
  "idd_code": "1",
  "area_code": "650",
  "weather_station_code": "USCA0746",
  "weather_station_name": "Mountain View",
  "mcc": "-",
  "mnc": "-",
  "mobile_brand": "-",
  "elevation": 32,
  "usage_type": "DCH",
  "address_type": "Anycast",
  "ads_category": "IAB19-11",
  "ads_category_name": "Data Centers",
  "continent": {
    "name": "North America",
    "code": "NA",
    "hemisphere": [
      "north",
      "west"
    ],
    "translation": {
      "lang": null,
      "value": null
    }
  },
  "country": {
    "name": "United States of America",
    "alpha3_code": "USA",
    "numeric_code": 840,
    "demonym": "Americans",
    "flag": "https://cdn.ip2location.io/assets/img/flags/us.png",
    "capital": "Washington, D.C.",
    "total_area": 9826675,
    "population": 339665118,
    "currency": {
      "code": "USD",
      "name": "United States Dollar",
      "symbol": "$"
    },
    "language": {
      "code": "EN",
      "name": "English"
    },
    "tld": "us",
    "translation": {
      "lang": null,
      "value": null
    }
  },
  "region": {
    "name": "California",
    "code": "US-CA",
    "translation": {
      "lang": null,
      "value": null
    }
  },
  "city": {
    "name": "Mountain View",
    "translation": {
      "lang": null,
      "value": null
    }
  },
  "time_zone_info": {
    "olson": "America/Los_Angeles",
    "current_time": "2025-07-30T21:08:34-07:00",
    "gmt_offset": -25200,
    "is_dst": true,
    "abbreviation": "PDT",
    "dst_start_date": "2025-03-09",
    "dst_end_date": "2025-11-02",
    "sunrise": "06:11",
    "sunset": "20:18"
  },
  "geotargeting": {
    "metro": "807"
  },
  "is_proxy": false,
  "fraud_score": 0,
  "proxy": {
    "last_seen": 1,
    "proxy_type": "DCH",
    "threat": "-",
    "provider": "-",
    "is_vpn": false,
    "is_tor": false,
    "is_data_center": true,
    "is_public_proxy": false,
    "is_web_proxy": false,
    "is_web_crawler": false,
    "is_residential_proxy": false,
    "is_consumer_privacy_network": false,
    "is_enterprise_private_network": false,
    "is_spammer": false,
    "is_scanner": false,
    "is_botnet": false,
    "is_bogon": false
  }
}

Note: The abbreviation, dst_start, and dst_end fields are only available for the Plus and Security plan user. Please purchase the plan before proceeding.

Convert UTC to Local Time

To convert a UTC timestamp to the user’s local time, you can use the time_zone_info >> olson

value (e.g., America/New_York) returned from the IP2Location.io API. Most modern programming languages have built-in libraries that allow you to apply this timezone directly to a UTC datetime, automatically adjusting for daylight saving time if applicable.

Below are the example code snippet that can be used to convert a UTC time to local time:

<?php
$apiKey = 'YOUR_API_KEY';
$ip = $_SERVER['REMOTE_ADDR'];

// Call the IP2Location.io API
$apiUrl = "https://api.ip2location.io/?key=$apiKey&ip=$ip";
$response = file_get_contents($apiUrl);
$data = json_decode($response, true);

// Get the Olson timezone from time_zone_info
$olson = $data['time_zone_info']['olson'] ?? 'UTC';

// Create and format local time
$utcTime = new DateTime('now', new DateTimeZone('UTC'));
$localTime = $utcTime->setTimezone(new DateTimeZone($olson));

echo "Local time in $olson: " . $localTime->format('Y-m-d H:i:s T');
?>

import requests
from datetime import datetime
from zoneinfo import ZoneInfo  # Python 3.9+

api_key = "YOUR_API_KEY"
ip = "8.8.8.8"  # Example, can change accordingly

# Fetch data from IP2Location.io
response = requests.get(f"https://api.ip2location.io/?key={api_key}&ip={ip}")
data = response.json()

# Extract Olson timezone
olson = data.get("time_zone_info", {}).get("olson", "UTC")

# Convert and format local time
utc_now = datetime.now().replace(tzinfo=ZoneInfo("UTC"))
local_time = utc_now.astimezone(ZoneInfo(olson))

print(f"Local time in {olson}: {local_time.strftime('%Y-%m-%d %H:%M:%S %Z')}")

const fetch = require('node-fetch');
const { DateTime } = require('luxon'); // Both are installable using npm install node-fetch@2 luxon

const apiKey = 'YOUR_API_KEY';
const ip = '8.8.8.8'; // Replace with actual IP

(async () => {
  const response = await fetch(`https://api.ip2location.io/?key=${apiKey}&ip=${ip}`);
  const data = await response.json();

  const olson = data.time_zone_info?.olson || 'UTC';

  const localTime = DateTime.utc().setZone(olson);
  console.log(`Local time in ${olson}: ${localTime.toFormat('yyyy-MM-dd HH:mm:ss ZZZZ')}`);
})();

Handling DST & Display Time on Website

The dst_start and dst_end fields definitely come in handy especially if you need to solve the time issue in the countries that are observing DST. By utilizing both fields, you can easily determine whether the country is currently observing DST.

Nowadays, most timezone libraries automatically take into account when calculating the local time for those countries that are observing DST. Most of the time, by using the library, you will not have a problem getting the accurate local time calculated with the DST factored in. However, sometimes the government may choose to continue observing the DST in the upcoming year or not. If the libraries haven’t been updated to handle the changes, you still can use IP2Location.io API result to make a quick check on whether the DST is in effect or not.

Below is a simple example of how to show the formatted local time in a website:

<?php
// Replace with your actual API key
$apiKey = 'YOUR_API_KEY';
// Get the user's IP address (fallbacks to REMOTE_ADDR if not behind proxy)
$ip = $_SERVER['HTTP_X_FORWARDED_FOR'] ?? $_SERVER['REMOTE_ADDR'];

// Call IP2Location.io API
$apiUrl = "https://api.ip2location.io/?key=$apiKey&ip=$ip";
$response = file_get_contents($apiUrl);
$data = json_decode($response, true);

// Fallback timezone
$timezone = $data['timezone'] ?? 'UTC';

// Create datetime in user's local timezone
$utc = new DateTime('now', new DateTimeZone('UTC'));
$local = $utc->setTimezone(new DateTimeZone($timezone));
$formattedTime = $local->format('Y-m-d H:i:s T');
?>
<!DOCTYPE html>
<html>
<head>
  <title>Local Time Display</title>
</head>
<body>
  <p>Your local time is: <strong><?php echo $formattedTime; ?></strong></p>
</body>
</html>

Conclusion

Displaying accurate local time for your user isn’t a difficult task. With IP2Location.io IP Geolocation API, you can easily achieve the mission in a few steps, starting with detecting the user’s IP address, fetching the timezone information, and converting and displaying the local time. The IP2Location.io API will benefit you in many ways, such as improving user experience, ensuring effective communication, and delivering accurate datetime information — including adjustments for daylight saving time where applicable.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

Using IP2Location MMDB inside Wireshark for geolocation

IP2Location — Fri, 20 Jun 2025 09:32:30 +0000

Wireshark is a powerful, open-source network protocol analyzer used to capture and inspect data traveling through a network in real time. It's commonly used by network administrators, security professionals, developers, and IT engineers for tasks such as network troubleshooting and security analysis. With the newly released IP2Location MMDB, users can now enhance their network traffic analysis by integrating IP geolocation data directly within Wireshark.

One useful feature that is beneficial for troubleshooting and analysis is the ability to get geolocation data for the IP addresses found in the network packets. Wireshark does this by querying MaxMind’s GeoIP2 or GeoLite2 databases which comes in the MMDB format. This format was created for fast IP address lookups.

IP2Location now includes MMDB format

Now, users of the IP2Location’s geolocation databases have the ability to download data in the MMDB format so they can easily use IP2Location’s data within Wireshark. There are 3 MMDB files supplied by IP2Location that corresponds to the equivalent MaxMind files. They are the LITE DB1 (equivalent of GeoLite2 Country), LITE DB9 (equivalent of GeoLite2 City) and LITE ASN (equivalent of GeoLite2 ASN). For this article, we’ll focus on the free IP2Location LITE DB9 & ASN MMDB databases to show how to query geolocation data within Wireshark.

Installing Wireshark

In order to follow our guide below, you will need to install Wireshark for your operating system. For our demo, we’ll be using Windows 11, hence we’ll install the relevant Wireshark version.

Download the IP2Location LITE DB9 & ASN MMDB databases

Now, we need to download the IP2Location LITE DB9 & ASN MMDB databases so we can perform city-level geolocation & ASN queries inside Wireshark. You can sign up and download the free LITE DB9 & ASN MMDB files from https://lite.ip2location.com/ip2location-lite#devto.

Under the IP2Location Database tab, download the LITE DB9 MMDB file.

After downloading the zipped file, extract the IP2LOCATION-LITE-DB9.MMDB and store it in a folder called C:\TestWireShark. Create the folder if it doesn’t exist.

Next, we’ll download the LITE ASN MMDB file under the ASN Database tab.

After downloading the zipped file, extract the IP2LOCATION-LITE-ASN.MMDB and store it in the same folder as above.

WARNING: You will need to rename both files so that the file extension is .mmdb instead of .MMDB as Wireshark will not be able to read the files if the file extension is in upper case.

Configure Wireshark to enable the IP geolocation feature

Launch Wireshark then in the menu bar, click on Edit -> Preferences.

Inside the Preferences, click on Name Resolution on the left-hand side. Then, click on Edit next to the MaxMind database directories.

Add the path to our folder from above inside the MaxMind Database Paths. This is so that Wireshark knows where to look for the MMDB files to query.

Keep pressing OK until you are back in the main Wireshark window.

Choose which network adapter to capture traffic

Double-click on the network adapter that you wish to capture traffic from. In our case, it is Wi-Fi.

It should start to capture network traffic like below from the Wi-Fi adapter.

Let’s stop the data capture and analyse the data

Once we’ve collected enough network traffic, press the Stop capturing packets button and take a closer look at the geolocation data for the IP addresses in the captured data. Click on one of the lines of traffic, then click on Internet Protocol Version 6 and you’ll see the below.

You can see that the source of the traffic is coming from Sydney in Australia while the Autonomous System (AS) shows that the IP belongs to Google. Meanwhile, you can see that the destination for the traffic is Bayan Lepas in Malaysia and the AS is telling us that the IP is from TM Technology Services.

View geolocation for all endpoints

Viewing a single line of traffic may or may not be useful depending on your goals. Wireshark has the ability to display geolocation for all of the endpoints captured. Let’s take a look. In the menu bar, click on Statistics -> Endpoints.

Inside, you can click on the IPv4 or the IPv6 tab and you can view the related geolocation data along with the Autonomous System (AS) info. This overview is a great way to quickly spot anomalous data or suspicious traffic.

Visualize the geolocation on a map

Sometimes, you just need a form of visualization to do your job more efficiently. Fortunately, Wireshark can easily plot the geolocation on a map for your viewing pleasure. Click on Map -> Open in browser.

You can now see the geolocation data rendered on a map below. With just a glance, you can easily see if you have traffic coming from any region that you don’t expect to receive traffic.

Use geolocation to filter the traffic data

The geolocation data is also handy if you wish to filter your captured traffic data. This could be especially useful when you are doing network troubleshooting. No point viewing unrelated traffic.

Let’s close the Endpoints window and go back to the main window. For example, if I want to filter traffic coming from Sydney, I can just right-click on the city name and click Prepare as filter -> Selected.

You’ll now see the below with the filter created in the green bar below. Just press the arrow at the end of the green bar to apply the filter.

Now, you will only see traffic coming from Sydney.

Conclusion

It is that simple to use IP2Location LITE DB9 and ASN MMDB files in Wireshark to provide geolocation and ASN data enrichment. Hopefully, this article can guide IP2Location users to fully utilize the power of IP2Location within Wireshark.

Disclaimer

MaxMind and GeoIP are registered trademarks of MaxMind, Inc. Wireshark and the “fin” logo are registered trademarks of the Wireshark Foundation.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

How to use IP2Location.io and IP2WHOIS in Django?

IP2Location — Tue, 20 Aug 2024 05:04:05 +0000

Django is a widely-used, free and open source web framework built in Python. It allows web developers to get started to build their website easily. Furthermore, to support their web application development, developers will have numerous external packages to choose from. Those packages can help with improving the user experience and reducing hassle for managing a website. For example, a site admin can use packages to detect where their site visitors are coming from. Such information will help with designing region-specific content. In this article, we will show you how to use IP2Location.io and IP2WHOIS API to perform geolocation and domain WHOIS lookup in Django.

Prerequisite

Before we start, you will be required to install the following components into your server.

IP2Location.io Python SDK

To perform geolocation lookup, you need to install it using this command: pip install ip2location-io.

IP2WHOIS Python SDK

To perform domain WHOIS lookup, you need to install it using this command: pip install IP2WHOIS.

You will also need a IP2Location.io API key to perform any type of lookup. You can sign up for a free API key, or purchase a plan according to your need.

Steps

Step 1:
Open your terminal, and create a new Django project by using the following command:
django-admin startproject mysite

Step 2:
A new folder with the name mysite will be created. Cd to the folder, and type the following command to create a new Django app:
python manage.py startapp myapp

Step 3:
We will then start to create the view of the app. Open the mysite/myapp/views.py file, and add the following code into the file:



from django.shortcuts import render
from django.template import loader
import ip2locationio
import ip2whois

# Create your views here.
from django.http import HttpResponse

from django.shortcuts import redirect

def get_client_ip(request):
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip

def geolocation_lookup(request):

    template = loader.get_template('myapp/view-ip2locationio-result.html')
    ip = get_client_ip(request)
    if ip == '127.0.0.1': # Only define the IP if you are testing on localhost.
        ip = '8.8.8.8'

    # Configures IP2Location.io API key
    configuration = ip2locationio.Configuration('YOUR_API_KEY')
    ipgeolocation = ip2locationio.IPGeolocation(configuration)

    rec = ipgeolocation.lookup(ip)
    context = {
        'ip': ip,
        'country_code': rec['country_code'],
        'country_name': rec['country_name'],
        'region_name': rec['region_name'],
        'city_name': rec['city_name'],
        'latitude': rec['latitude'],
        'longitude': rec['longitude'],
        'zip_code': rec['zip_code'],
        'time_zone': rec['time_zone'],
        'asn': rec['asn'],
        'asname': rec['as'],
        'is_proxy': 'True' if rec['is_proxy'] else 'False',
    }

    return HttpResponse(template.render(context, request))

def whois_lookup(request):

    template = loader.get_template('myapp/view-ip2whois-result.html')
    domain = "locaproxy.com" # We will use a fixed value for domain name in this tutorial, but you can always change it to accept input from a form or url.
    # Configures IP2WHOIS API key
    ip2whois_init = ip2whois.Api('YOUR_API_KEY')

    # Lookup domain information
    results = ip2whois_init.lookup(domain)

    # Convert JSON to Python dictionary
    # data = json.loads(results)

    # Pass the data to the template
    return HttpResponse(template.render(results, request))

Step 4:
In the same directory, create a new file called urls.py. Open this file, and add the following code into it:



from django.urls import path

from . import views

urlpatterns = [
    path('lookup', views.geolocation_lookup, name='geolocation_lookup'),
    path('whoislookup', views.whois_lookup, name='whois_lookup'),
]

Step 5:
We will also need to create a template file for displaying the result. Under the myapp_folder, create a new folder called _templates, and under the templates folder create another new folder called myapp.

Step 6:
Inside the mysite/myapp/templates/myapp folder, create two new html files called view-ip2locationio-result.html and view-ip2whois-result.html. Copy the following code into both html files:



<!-- view-ip2locationio-result.html -->
<html>
   <head>
        <title>View IP2Location.io result</title>
   </head>
   <body>
      <p>IP: {{ip}}</p>
      <p>Country Code: {{country_code}}</p>
      <p>Country Name : {{country_name}}</p>
      <p>Region Name: {{region_name}}</p>
      <p>City Name: {{city_name}}</p>
      <p>Latitude: {{latitude}}</p>
      <p>Longitude: {{longitude}}</p>
      <p>ZIP Code: {{zip_code}}</p>
      <p>Time Zone: {{time_zone}}</p>
      <p>ASN: {{asn}}</p>
      <p>AS Name: {{asname}}</p>
      <p>Is Proxy: {{is_proxy}}</p>
   </body>

</html>



<!-- view-ip2whois-result.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Domain Information: {{ domain }}</title>
</head>
<body>
    <h1>Domain Information for {{ domain }}</h1>
    <p><strong>Domain ID:</strong> {{ domain_id }}</p>
    <p><strong>Status:</strong> {{ status }}</p>
    <p><strong>Creation Date:</strong> {{ create_date }}</p>
    <p><strong>Update Date:</strong> {{ update_date }}</p>
    <p><strong>Expiration Date:</strong> {{ expire_date }}</p>
    <p><strong>Domain Age:</strong> {{ domain_age }} days</p>
    <p><strong>WHOIS Server:</strong> {{ whois_server }}</p>

    <h2>Registrar Information</h2>
    <p><strong>IANA ID:</strong> {{ registrar.iana_id }}</p>
    <p><strong>Name:</strong> {{ registrar.name }}</p>
    <p><strong>URL:</strong> <a href="{{ registrar.url }}">{{ registrar.url }}</a></p>

    <h2>Registrant Information</h2>
    <p><strong>Name:</strong> {{ registrant.name }}</p>
    <p><strong>Organization:</strong> {{ registrant.organization }}</p>
    <p><strong>Street Address:</strong> {{ registrant.street_address }}</p>
    <p><strong>City:</strong> {{ registrant.city }}</p>
    <p><strong>Region:</strong> {{ registrant.region }}</p>
    <p><strong>ZIP Code:</strong> {{ registrant.zip_code }}</p>
    <p><strong>Country:</strong> {{ registrant.country }}</p>
    <p><strong>Phone:</strong> {{ registrant.phone }}</p>
    <p><strong>Fax:</strong> {{ registrant.fax }}</p>
    <p><strong>Email:</strong> <a href="{{ registrant.email }}">{{ registrant.email }}</a></p>

    <h2>Administrative Contact Information</h2>
    <p><strong>Name:</strong> {{ admin.name }}</p>
    <p><strong>Organization:</strong> {{ admin.organization }}</p>
    <p><strong>Street Address:</strong> {{ admin.street_address }}</p>
    <p><strong>City:</strong> {{ admin.city }}</p>
    <p><strong>Region:</strong> {{ admin.region }}</p>
    <p><strong>ZIP Code:</strong> {{ admin.zip_code }}</p>
    <p><strong>Country:</strong> {{ admin.country }}</p>
    <p><strong>Phone:</strong> {{ admin.phone }}</p>
    <p><strong>Fax:</strong> {{ admin.fax }}</p>
    <p><strong>Email:</strong> <a href="{{ admin.email }}">{{ admin.email }}</a></p>

    <h2>Technical Contact Information</h2>
    <p><strong>Name:</strong> {{ tech.name }}</p>
    <p><strong>Organization:</strong> {{ tech.organization }}</p>
    <p><strong>Street Address:</strong> {{ tech.street_address }}</p>
    <p><strong>City:</strong> {{ tech.city }}</p>
    <p><strong>Region:</strong> {{ tech.region }}</p>
    <p><strong>ZIP Code:</strong> {{ tech.zip_code }}</p>
    <p><strong>Country:</strong> {{ tech.country }}</p>
    <p><strong>Phone:</strong> {{ tech.phone }}</p>
    <p><strong>Fax:</strong> {{ tech.fax }}</p>
    <p><strong>Email:</strong> <a href="{{ tech.email }}">{{ tech.email }}</a></p>

    <h2>Billing Contact Information</h2>
    <p><strong>Name:</strong> {{ billing.name }}</p>
    <p><strong>Organization:</strong> {{ billing.organization }}</p>
    <p><strong>Street Address:</strong> {{ billing.street_address }}</p>
    <p><strong>City:</strong> {{ billing.city }}</p>
    <p><strong>Region:</strong> {{ billing.region }}</p>
    <p><strong>ZIP Code:</strong> {{ billing.zip_code }}</p>
    <p><strong>Country:</strong> {{ billing.country }}</p>
    <p><strong>Phone:</strong> {{ billing.phone }}</p>
    <p><strong>Fax:</strong> {{ billing.fax }}</p>
    <p><strong>Email:</strong> {{ billing.email }}</p>

    <h2>Nameservers</h2>
    <ul>
        {% for nameserver in nameservers %}
            <li>{{ nameserver }}</li>
        {% endfor %}
    </ul>
</body>
</html>

Step 7:
In order to make sure that the page can be found and loaded, we still need to do some configuration. Open the mysite/mysite/urls.py, and add the following line in the urlpatterns list:
path('myapp/', include('myapp.urls')),

Step 8:
Open the mysite/mysite/settings.py, and add the following line into the INSTALLED_APPS list:
'myapp',

Step 9:
Remember to save all the changes. Next, change back to the project root directory and use the following command to start a Django development server:
python manage.py runserver

Step 10:
Now you can go to your browser, and navigate to http://127.0.0.1:8000/myapp/lookup and http://127.0.0.1:8000/myapp/whoislookup to see the outcome. You will see a similar output displayed in the screenshot below.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

How to use IP2Location.io and IP2WHOIS in Flask?

IP2Location — Fri, 05 Jul 2024 02:44:33 +0000

Introduction

Flask is a Python micro web framework that does not rely on any particular tool or library to work. Because of it’s simplicity and lightweight nature, many websites had adapted Flask into their backend, such as Pinterest and LinkedIn. Flask allows developers to use any third party extensions to add more functionality. For example, developers can utilize a geolocation lookup extension to lookup for the geolocation information of their visitor. In this article, we will show you how to use IP2Location.io and IP2WHOIS API to perform geolocation and domain WHOIS lookup in Flask.

Prerequisite

Before we start, you will be required to install the following components into your server.

IP2Location.io Python SDK
To perform geolocation lookup, you need to install it using this command: pip install ip2location-io.
IP2WHOIS Python SDK
To perform domain WHOIS lookup, you need to install it using this command: pip install IP2WHOIS.

You will also need a IP2Location.io API key to perform any type of lookup. You can sign up for a free API key, or purchase a plan according to your need.

Steps

Step 1:
In your local server, create a new directory called mywebsite, and navigate to the directory.

Step 2:
Create a new file called app.py, and paste the following code into the file:

from flask import Flask, render_template, jsonify, request
import ip2locationio
import ip2whois

app = Flask(__name__)

@app.route('/geolocation-lookup')
def geolocation_lookup():
    if request.environ.get('HTTP_X_FORWARDED_FOR') is None:
        ip = request.environ['REMOTE_ADDR']
    else:
        ip = request.environ['HTTP_X_FORWARDED_FOR']
    if ip == '127.0.0.1': # Happened in Windows, if the IP got is 127.0.0.1, need to substitute with real IP address
        ip = '8.8.8.8' # Google Public IP

    # Configures IP2Location.io API key
    configuration = ip2locationio.Configuration('YOUR_API_KEY')
    ipgeolocation = ip2locationio.IPGeolocation(configuration)

    rec = ipgeolocation.lookup(ip)
    return render_template('display_ip2locationio_result.html', data=rec)

@app.route('/whois-lookup')
def index():
    domain = "locaproxy.com" # We will use a fixed value for domain name in this tutorial, but you can always change it to accept input from a form or url.

    # Configures IP2WHOIS API key
    ip2whois_init = ip2whois.Api('YOUR_API_KEY')

    # Lookup domain information
    results = ip2whois_init.lookup(domain)
    return render_template('display_ip2whois_result.html', data=results)

if __name__ == '__main__':
    app.run(debug=True)

Step 3:
Create a new sub directory called templates. Then, in the templates folder, create two new html files called display_ip2locationio_result.html and display_ip2whois_result.html. Paste the following contents into both files respectively:

<!-- display_ip2locationio_result.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>IP Information</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-bottom: 20px;
        }
        table, th, td {
            border: 1px solid #ccc;
        }
        th, td {
            padding: 10px;
            text-align: left;
        }
        th {
            background-color: #f4f4f4;
        }
    </style>
</head>
<body>
    <h1>IP Information for {{ data.ip }}</h1>
    <table>
        <tr>
            <th>Field</th>
            <th>Value</th>
        </tr>
        <tr>
            <td>IP</td>
            <td>{{ data.ip }}</td>
        </tr>
        <tr>
            <td>Country Code</td>
            <td>{{ data.country_code }}</td>
        </tr>
        <tr>
            <td>Country Name</td>
            <td>{{ data.country_name }}</td>
        </tr>
        <tr>
            <td>Region Name</td>
            <td>{{ data.region_name }}</td>
        </tr>
        <tr>
            <td>City Name</td>
            <td>{{ data.city_name }}</td>
        </tr>
        <tr>
            <td>Latitude</td>
            <td>{{ data.latitude }}</td>
        </tr>
        <tr>
            <td>Longitude</td>
            <td>{{ data.longitude }}</td>
        </tr>
        <tr>
            <td>Zip Code</td>
            <td>{{ data.zip_code }}</td>
        </tr>
        <tr>
            <td>Time Zone</td>
            <td>{{ data.time_zone }}</td>
        </tr>
        <tr>
            <td>ASN</td>
            <td>{{ data.asn }}</td>
        </tr>
        <tr>
            <td>AS</td>
            <td>{{ data.as }}</td>
        </tr>
        <tr>
            <td>Is Proxy</td>
            <td>{{ data.is_proxy }}</td>
        </tr>
    </table>
</body>
</html>

<!-- display_ip2whois_result.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Domain Information</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
        }
        table {
            width: 100%;
            border-collapse: collapse;
            margin-bottom: 20px;
        }
        table, th, td {
            border: 1px solid #ccc;
        }
        th, td {
            padding: 10px;
            text-align: left;
        }
        th {
            background-color: #f4f4f4;
        }
    </style>
</head>
<body>
    <h1>Domain Information for {{ data.domain }}</h1>
    <table>
        <tr>
            <th>Field</th>
            <th>Value</th>
        </tr>
        <tr>
            <td>Domain</td>
            <td>{{ data.domain }}</td>
        </tr>
        <tr>
            <td>Domain ID</td>
            <td>{{ data.domain_id }}</td>
        </tr>
        <tr>
            <td>Status</td>
            <td>{{ data.status }}</td>
        </tr>
        <tr>
            <td>Create Date</td>
            <td>{{ data.create_date }}</td>
        </tr>
        <tr>
            <td>Update Date</td>
            <td>{{ data.update_date }}</td>
        </tr>
        <tr>
            <td>Expire Date</td>
            <td>{{ data.expire_date }}</td>
        </tr>
        <tr>
            <td>Domain Age</td>
            <td>{{ data.domain_age }} days</td>
        </tr>
        <tr>
            <td>Whois Server</td>
            <td>{{ data.whois_server }}</td>
        </tr>
        <tr>
            <td>Registrar</td>
            <td>
                Name: {{ data.registrar.name }}<br>
                URL: <a href="{{ data.registrar.url }}" target="_blank">{{ data.registrar.url }}</a><br>
                IANA ID: {{ data.registrar.iana_id }}
            </td>
        </tr>
        <tr>
            <td>Registrant</td>
            <td>
                Name: {{ data.registrant.name }}<br>
                Organization: {{ data.registrant.organization }}<br>
                Address: {{ data.registrant.street_address }}, {{ data.registrant.city }}, {{ data.registrant.region }} {{ data.registrant.zip_code }}, {{ data.registrant.country }}<br>
                Phone: {{ data.registrant.phone }}<br>
                Fax: {{ data.registrant.fax }}<br>
                Email: {{ data.registrant.email }}
            </td>
        </tr>
        <tr>
            <td>Admin</td>
            <td>
                Name: {{ data.admin.name }}<br>
                Organization: {{ data.admin.organization }}<br>
                Address: {{ data.admin.street_address }}, {{ data.admin.city }}, {{ data.admin.region }} {{ data.admin.zip_code }}, {{ data.admin.country }}<br>
                Phone: {{ data.admin.phone }}<br>
                Fax: {{ data.admin.fax }}<br>
                Email: {{ data.admin.email }}
            </td>
        </tr>
        <tr>
            <td>Tech</td>
            <td>
                Name: {{ data.tech.name }}<br>
                Organization: {{ data.tech.organization }}<br>
                Address: {{ data.tech.street_address }}, {{ data.tech.city }}, {{ data.tech.region }} {{ data.tech.zip_code }}, {{ data.tech.country }}<br>
                Phone: {{ data.tech.phone }}<br>
                Fax: {{ data.tech.fax }}<br>
                Email: {{ data.tech.email }}
            </td>
        </tr>
        <tr>
            <td>Billing</td>
            <td>
                Name: {{ data.billing.name }}<br>
                Organization: {{ data.billing.organization }}<br>
                Address: {{ data.billing.street_address }}, {{ data.billing.city }}, {{ data.billing.region }} {{ data.billing.zip_code }}, {{ data.billing.country }}<br>
                Phone: {{ data.billing.phone }}<br>
                Fax: {{ data.billing.fax }}<br>
                Email: {{ data.billing.email }}
            </td>
        </tr>
        <tr>
            <td>Nameservers</td>
            <td>
                <ul>
                    {% for nameserver in data.nameservers %}
                        <li>{{ nameserver }}</li>
                    {% endfor %}
                </ul>
            </td>
        </tr>
    </table>
</body>
</html>

Step 4:
In your terminal, navigate to the project directory, and run the following command to start the local server: flask run.
Take note that if you named the app.py to other name such as website.py, the command will become flask --app website run instead.

Step 5:
Now you can go to your browser, and navigate to the link http://127.0.0.1:5000/geolocation-lookup and http://127.0.0.1:5000/whois-lookup to see the results. You will see similar outputs displayed in the screenshot below.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

Using IP2Convert to create MMDB geolocation database for use with WireShark

IP2Location — Wed, 05 Jun 2024 02:28:50 +0000

WireShark is a free and open-source packet analyzer. It can be used to check for network attacks or to troubleshoot networking issues. Meanwhile, MMDB is a database format created by MaxMind for IP lookup. Inside WireShark, there is an option to retrieve IP geolocation data using the MMDB IP database. In this article, we’ll explore how to use IP2Convert Geolocation File Format Converter to read data from IP2Location LITE DB9 IPv6 CSV file and generate the corresponding GeoLite2 City MMDB file.

So why the need for conversion?

Wireshark natively supports the MMDB format from MaxMind for geolocation services. However, if you want to use an alternative geolocation service like IP2Location, there is no external plugin available for integration. The only method would be via the MMDB data file. Therefore, this tutorial provides a workaround to convert the IP2Location CSV file into MMDB format so it can be used by WireShark with the geolocation function turned on.

Let’s get started with our guide for the conversion.

Installing WireShark

First and foremost, you will need to have WireShark installed on your system. In our case, we are doing the conversion using our Windows 11 machine, hence the steps will be more Windows-specific. Do note however that WireShark can also be used in Linux or macOS. You can just change the steps for the platform you are using. We’ll download WireShark from https://www.wireshark.org/download.html and install it in our Windows 11.

Download the IP2Convert tool

Now, we’ll download the free IP2Convert tool from GitHub at https://github.com/ip2location/ip2convert/releases/latest where we will get the windows_amd64 version. Remember to download the version specific to your platform. Extract the .exe file into a folder. In our case, we’ll use C:\TestWireShark\ as our folder to store the IP2Convert executable.

Download the IP2Location LITE DB9 IPv6 CSV

Download the IP2Location LITE DB9 IPv6 CSV file which you can download for free after signing up for an account. Extract the file IPV6-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE.CSV from the downloaded zipped file and save it to the same folder as above.

Your TestWireShark folder should now look like the below:

In our case, the latest version of the IP2Convert at the point of writing is 1.2.1 so that’s what you’ll see above. To make it easier to type, let's rename the .exe to ip2convert.exe so that we don’t have to type so long in the next steps.

Let’s generate the MMDB file

Open a Command Prompt window and navigate to the TestWireShark folder.



cd C:\TestWireShark

Then run the below command to perform the CSV to MMDB conversion.



ip2convert csv2mmdb -t city -i IPV6-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE.CSV -o DB9IPV6.mmdb

The -t parameter is to specify that we want to generate the GeoLite2 City MMDB while the -i and -o are used to specify the input CSV file and output MMDB file.

Launch WireShark and configure the IP geolocation function

Launch WireShark then click on “Edit” in the menu bar. Click on “Preferences”.

You should now see the Preferences window. Click on “Name Resolution” on the left hand side. There are a couple of settings we need to set. Make sure the “Enable IP geolocation” checkbox is checked. Next, click on “Edit” next to the “MaxMind database directories”.

Add the folder that we’ve created above into the list. Then click on OK.

Select the network adapter to capture traffic

You can double click on the network adapter that you want to capture the network traffic from. In our example, it’s “Ethernet 2”.

Start the network traffic capture

Click the start capture button and you should start seeing a bunch of traffic coming and going from the adapter you’ve selected.

Take a look at the inline geolocation data

Once you’ve captured enough traffic, we can stop the capture and delve into the IP geolocation data. Let’s click on one of the lines of traffic and expand the “Internet Protocol Version 6” section so we can see the IP geolocation for the traffic source & destination.

We can see that the source of the traffic is Sydney, Australia while the destination is Kuala Lumpur, Malaysia.

See the geolocation for all endpoints

That’s just 1 line of traffic. Now, let’s go to the Endpoints window to view all of the geolocation traffic. In the menu, click on “Statistics” and then click on “Endpoints”.

Inside, you’ll see the below. Just click on the IPv4 or IPv6 tab and you can view all of the IP geolocation data. Pretty good way to quickly scan for potential issues.

View the geolocations on a map

Looking at the list of locations is useful for troubleshooting and security purposes. But, sometimes you want to have a nice visual representation of the locations. That’s what the map feature is for. With the locations plotted on a map, you can easily discern if the traffic is coming from specific regions. Click on “Map” then click on “Open in browser”.

All of the geolocation is now shown in the map below. Pretty interesting and useful.

Bonus Tip: Filtering the traffic by geolocation

Let’s close the Endpoints window and take another look at the main capture window. The data, while useful, certainly could use some filtering to make more sense. Say that I want to see traffic to Dublin. We can easily right-click on the city name and click “Prepare as Filter” then click “Selected”.

You’ll now see the filter created near the top of the window. Press the arrow at the end of the green bar and you’ll see the filtering being applied.

Now, you’ll only see traffic that matches the filter which is Dublin, Ireland as the destination.

Conclusion

Hope you’ve found our little guide for using IP2Convert to create MMDB files and using them in WireShark to be useful in your day-to-day operations. With IP2Convert, you now have the flexibility to deploy IP geolocation data from IP2Location and use them wherever MMDB is supported. We’ve shown you how to use the generated MMDB in WireShark but you could potentially use the MMDB files in other applications that utilizes MMDB files for geolocation.

Disclaimer

MaxMind and GeoIP are registered trademarks of the MaxMind, Inc.
Wireshark and the “fin” logo are registered trademarks of the Wireshark Foundation.
IP2Location and IP2Proxy are registered trademarks of Hexasoft Development Sdn. Bhd.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

IP Geolocation API in Cerb

IP2Location — Tue, 23 Apr 2024 04:52:38 +0000

Introduction

Cerb is a web-based application designed for tasks automation and enterprise communication. With a history spanning over 22 years, Cerb continues their improvement based on feedback from a multitude of teams around the world. User can run Cerb on their own hardware, in Docker, or in Cerb Cloud as a fully managed service.

Cerb allows API integration by using two features called automations and interactions. Automations add conditional actions to any event, while interactions extend any toolbar for complex multi-step workflows that require user input. By doing so, user can make use of any API service to extend the Cerb feature. For example, they can use an external API service to get geolocation information before moving to the next step.

IP2Location.io is a geolocation API service that can provide fast and accurate IP geolocation data to determine a user’s location and use the geolocation information in different use cases. User can get geolocation information such as country, region, city plus proxy detection.

In this article, we will shows how to use the IP2Location.io IP Geolocation API in Cerb to get geolocation data. We will also brief on how to install Cerb in your local machine with Docker.

Prerequisites

Before we start, please ensure that the Docker and Git are installed in your local machine, as both will be used in Cerb installation process. The IP2Location.io API requires an API key to function. You may sign up for a free API key if you do not have one. Please note that the continent, country, region and city translations are only available in the IP2Location.io Plus and Security plans.

Install Cerb in local machine

1 Clone the latest release of Cerb into your machine by using git. For example, if the latest release is v10.4, you can close the release by running this command:

git clone -b v10.4 https://github.com/cerb/cerb-release.git v10.4

2 Navigate to the cloned release just now by

cd v10.4

3 Navigate to the docker file directory in the release by

cd install/docker

4 Run docker compose up –build to build and start the container for Cerb. The initial run will take a few minutes to complete the build of the container image. Subsequent runs will start the container almost immediately. Once the build process is complete and it starts running, you can then open your browser and navigate to the http://localhost/. The cerb guided installer will prompt you for all necessary information to complete the installation.

Step-by-step guide to use the IP2Location.io API in Cerb

1 Login to your Cerb dashboard if haven’t, and then click on the search icon as shown in the screenshot.

2 Click on the “(show all record types)”, look for the “Connected Services” and click on it.

3 Click on the + icon to add the IP2Location.io API.

4 Enter the following information to the form, and click the “Save Changes” button:

Field	Value
Name	ip2location
URI	ip2location
Type	API key
Base URL	https://api.ip2location.io/
API Key Name	key
API Key Location	URL parameter

5 After that, go back to the dashboard, and click the search icon showed in the step 1. Click on the “(show all record types)”, this time look for the “Connected Accounts” and click on it. Click on the + icon to add your IP2Location.io API key into Cerb.

6 Click “ip2location” from the selection, enter the following information to the form, and click the “Save Changes” button:

Field	Value
Name	ip2location
URI	ip2location
API key	(copy from IP2Location.io dashboard)
Base URL	https://api.ip2location.io/

7 Now you can use IP2Location.io API to get the geolocation information. To do so, first click the search icon showed in the step 1. Click on the “(show all record types)”, this time look for the “Automations” and click on it. Click on the + icon to add new automation in Cerb.

8 A popup form will be appear on the screen. Enter “ip2location” in the Name field. Set the trigger type as "cerb.trigger.automation.function”. After that, paste the following code into the text field as shown here:

inputs:
  text/ip:
    type: ip
    required@bool: yes

start:
  http.request:
    output: http_response
    inputs:
      method: GET
      url: https://api.ip2location.io/{{inputs.ip|url_encode}}
      authentication: cerb:connected_account:ip2location
    on_success:
      return:
        data@json: {{http_response.body}}
    on_error:
      error: {{http_response.error}}

9 You will also need to add a policy for the automation as recommended by Cerb. Click on the “Policy” tab, and paste the following content into the text field after the line “commands:”

http.request:
    deny/url@bool: {{inputs.url is not prefixed ('https://api.ip2location.io/')}}
    deny/account@bool: {{inputs.authentication not in ['cerb:connected_account:ip2location']}}
    allow@bool: yes

10 That’s all. Now you can try by using the following code. Click on the “Run” tab, and paste the code at the text field in the Input section:

inputs:
  ip: 1.2.3.4

11 Click on the triangle button to run the automation. If the run is success, you will see the output being shown in the Output section as shown in the screenshot. Click the “Save Changes” button to save the automation if you are satisfied with it.

Conclusion

This article demonstrates a basic usage of the IP2Location.io API in Cerb, along with the installation of Cerb using Docker. At the completion of this article, you will be able to perform an IP geolocation lookup by using the IP2Location.io API. This will give you more information on an IP address such as geolocation and proxy. These information can be helpful in later analysis, or security enhancement.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

Proxy and VPN detection in Ruby with IP2Location.io geolocation API

IP2Location — Fri, 08 Dec 2023 08:12:07 +0000

In the realm of web development and security, the need to identify and manage incoming requests from residential proxies and Virtual Private Networks (VPNs) is becoming increasingly crucial. Ruby, a dynamic and versatile programming language, offers an elegant solution to tackle this challenge. This article will explore the capabilities of Ruby in conjunction with the IP2Location.io Geolocation API, showing how this combination can be employed to detect residential proxies and VPNs effectively.

History of Ruby

Ruby, often referred to as an object-oriented scripting language, was created by Yukihiro Matsumoto also known as "Matz" in the mid-1990s. At its core, Ruby emphasizes simplicity and readability, aiming to optimize developer happiness. The language's syntax is designed to be human-readable and expressive, allowing developers to write clean and concise code.
One of Ruby's distinguishing features is its dynamic nature. Unlike statically typed languages, Ruby does not require explicit variable type declarations, enabling developers to focus on solving problems rather than dealing with complex type systems. This dynamism also contributes to the language's flexibility, allowing for the creation of dynamic and highly modular applications.

What sets Ruby apart from other programming languages is its vibrant community, which is known for its inclusivity and collaboration. It has contributed to the development of a rich ecosystem of libraries and frameworks. The availability of gems, which are Ruby's packaged libraries, facilitates rapid application development by providing pre-built solutions to common problems.

Now, provided with a deeper understanding of Ruby's style and versatility, it’s time to explore the challenges posed by residential proxies and VPNs and how Ruby can be employed to address them.

Understanding Residential Proxies and VPNs

Residential Proxies:

Residential proxies involve routing internet traffic through IP addresses assigned by Internet Service Providers (ISPs) to homeowners. The use of residential proxies provides a layer of authenticity to web requests, making it appear as if they originate from genuine residential users. This authenticity is valuable in scenarios such as web scraping, market research and other applications where genuine user behavior is crucial.

Virtual Private Networks (VPNs):

VPNs, on the other hand, create a secure tunnel between the user's device and the internet. They encrypt the user's internet connection, providing anonymity and security by masking the user's IP address. While VPNs are commonly used for privacy and bypassing regional restrictions, they can also be employed to mask the origin of web requests.

Checking for Residential Proxies and VPNs using Ruby

Ruby's flexibility comes into play when developers need to identify whether incoming requests are from regular users, residential proxies, or VPNs. The IP2Location.io Geolocation API proves to be a valuable ally in this attempt. This API provides comprehensive information about the geographical location, connection type and proxy details associated with an IP address.
IP2Location.io provides a Ruby SDK that simplifies the integration of their geolocation API into Ruby applications. This SDK allows developers to easily retrieve information about the location and type of IP addresses, making it an invaluable tool for identifying residential proxies and VPNs.

To begin using the IP2Location.io Ruby SDK, developers need to obtain an API key from the IP2Location.io website. This key serves as an authentication token for accessing the geolocation data. It is necessary to have a Security Plan subscription to obtain access to information regarding residential proxies and VPNs. After completing the subscription procedure, you can locate the API key on the dashboard page. With the intention of gaining a better understanding of the raw data received from the API, an example of an IP Geolocation API query is presented on the dashboard page.

Once armed with the API key, developers can proceed to install the IP2Location.io SDK Ruby gem using the following command:

gem install ip2location_io_ruby

With the ip2location_io_ruby gem installed, developers can now use the IP2Location.io Ruby SDK to perform geolocation lookups. The following demonstration is a basic example:

require 'ip2location_io_ruby'

IP2LocationIORuby::Configuration.api_key = 'YOUR_API_KEY'

begin
    result = IP2LocationIORuby::Api::IPGeolocation.lookup('IP_ADDRESS')
rescue Exception => e
    puts e.message
else
    if JSON[result.body]['proxy']['is_residential_proxy']
        puts 'Residential proxy detected.'
    elsif JSON[result.body]['proxy']['is_vpn']
        puts 'VPN detected.'
    else
        puts 'No residential proxy or VPN detected.'
    end
end

In this example, the ip2location_io_ruby gem file is included. The API key that is obtained from the IP2Location.io dashboard page is configured. Then, the lookup method is utilized to retrieve comprehensive geolocation information for a specific IP address. The analysis of the API response that follows is employed to ascertain whether the user is using a residential proxy or a VPN.
In a nutshell, Ruby's elegance, readability, and dynamic nature make it an excellent choice for handling the details of identifying residential proxies and VPNs. By seamlessly integrating the IP2Location.io Ruby SDK, developers can tap into a wealth of geolocation data to strengthen the security and authenticity of their applications.

As the digital landscape continues to evolve, the combination of Ruby and the IP2Location.io Geolocation API remains a potent tool in the hands of developers seeking to navigate the complexities of web security. Whether developing a web scraper, enhancing user experience or fortifying applications against potential threats, the grouping of Ruby and IP2Location.io provides a robust solution in the ever-changing landscape of online security.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

Using Go to check for proxy and VPN with IP2Location.io geolocation API

IP2Location — Wed, 06 Dec 2023 05:00:05 +0000

Intro

Go or Golang, is an open-source programming language created by Google. If you are familiar with the C programming language syntax, then you’ll feel right at home using Go. It has garbage collection and memory safety, in addition to being fast. In addition, it is very useful for concurrency programming.

Developers use Go for a variety of programs like microservices, networking services, web applications, command line interfaces and more. Go developers have a huge variety of packages at their disposal to perform just about any task. Among them is the IP2Location.io Go SDK that provides a wrapper for the IP2Location.io API. The IP2Location.io API enables developers to easily check if an IP address belongs to a Virtual Private Network (VPN) or a residential proxy.

What is a VPN?

So, what is a VPN, you may ask? Well, a VPN server is essentially a proxy server that makes web requests on your behalf like a middleman. It hides your actual IP address from websites so that they are unable to track you. When a user is using a VPN server to browse a website, the user’s request is passed to the VPN server which then makes the request at the website. The response from the website is passed back along the same path. The traffic between the VPN server and the user is encrypted. That means the user’s ISP or other parties are unable to intercept any meaningful data from the network packets. It’s great for privacy reasons.

What is a residential proxy?

Another type of proxy called a residential proxy, performs similarly to the above VPN server. The only difference is that the residential proxy server is usually a home user’s computer vs. the data center machine used in VPN. People usually use residential proxies whenever they wish to hide the fact that they’re using a proxy server.

Why do we need to detect VPN or residential proxy?

As mentioned above, proxy servers serve to obscure the identities of the users. This means that they could be up to no good. Fraudsters frequently use VPN or residential proxy to fool online stores and bypass their fraud checks when buying stuff. People also use proxies to circumvent geofencing to get access to streaming video or music. Operators of such websites definitely need to be able to detect VPN and residential proxies, in order to block them.

Using IP2Location.io to detect VPN and residential proxy

Let’s take a look at how to use the IP2Location.io Go SDK to query the IP2Location.io API to determine if an IP address belongs to a VPN or a residential proxy.

Sign up for the IP2Location.io API key
But, before we can proceed, please make sure to sign up for the API key. You’ll need to subscribe to the Plus plan to be able to have access to the VPN and residential proxy data.

Once you’ve subscribed, you can login to the website and retrieve your API key. We’ll need that to query the API.

As you can see in the screenshot above, there is an example API query which you can copy & paste into your browser to see the JSON result. This will give you an idea of the raw data returned by the API. You can try out the URL below with your API key and any IP address you wish to query.

E.g., https://api.ip2location.io/?key=<YOUR _API_KEY>&ip=<IP_TO_QUERY>

But in our case, we’ll be using the IP2Location.io Go SDK to parse the raw JSON into a struct for us to easily use. We are going to create a command line program to query the API for a particular IP address and show the results.

Create your testing Go project first if you don’t have one
1) Create a folder and call it test_project.
2) In the command prompt, navigate into that folder.
3) Run go mod init test to initialize the go.mod file.
4) Next, run go get github.com/ip2location/ip2location-io-go to add IP2Location.io Go SDK into the project.
5) After that, create a sub-folder called test inside the test_project folder where we’ll store our test code.
6) Navigate into the test folder.
7) Create a blank text file called test.go which will contain our code.

Basic usage code for the IP2Location.io Go SDK
Head on over to the quick start page below:
https://ip2location-io-go.readthedocs.io/en/latest/quickstart.html

Copy the code and paste into the test.go file.

package main

import (
    "github.com/ip2location/ip2location-io-go/ip2locationio"
    "fmt"
)

func main() {
    apikey := "YOUR_API_KEY"

    config, err := ip2locationio.OpenConfiguration(apikey)

    if err != nil {
        fmt.Print(err)
        return
    }
    ipl, err := ip2locationio.OpenIPGeolocation(config)

    if err != nil {
        fmt.Print(err)
        return
    }

    ip := "8.8.8.8"
    lang := "en" // set to blank string if not applicable
    res, err := ipl.LookUp(ip, lang) // language parameter only available with Plus and Security plans

    if err != nil {
        fmt.Print(err)
        return
    }

    fmt.Printf("IP => %+v\n", res.IP)
    fmt.Printf("CountryCode => %+v\n", res.CountryCode)
    fmt.Printf("CountryName => %+v\n", res.CountryName)
    fmt.Printf("RegionName => %+v\n", res.RegionName)
    fmt.Printf("CityName => %+v\n", res.CityName)
    fmt.Printf("Latitude => %+v\n", res.Latitude)
    fmt.Printf("Longitude => %+v\n", res.Longitude)
    fmt.Printf("ZipCode => %+v\n", res.ZipCode)
    fmt.Printf("TimeZone => %+v\n", res.TimeZone)
    fmt.Printf("Asn => %+v\n", res.Asn)
    fmt.Printf("AS => %+v\n", res.AS)
    fmt.Printf("Isp => %+v\n", res.Isp)
    fmt.Printf("Domain => %+v\n", res.Domain)
    fmt.Printf("NetSpeed => %+v\n", res.NetSpeed)
    fmt.Printf("IddCode => %+v\n", res.IddCode)
    fmt.Printf("AreaCode => %+v\n", res.AreaCode)
    fmt.Printf("WeatherStationCode => %+v\n", res.WeatherStationCode)
    fmt.Printf("WeatherStationName => %+v\n", res.WeatherStationName)
    fmt.Printf("Mcc => %+v\n", res.Mcc)
    fmt.Printf("Mnc => %+v\n", res.Mnc)
    fmt.Printf("MobileBrand => %+v\n", res.MobileBrand)
    fmt.Printf("Elevation => %+v\n", res.Elevation)
    fmt.Printf("UsageType => %+v\n", res.UsageType)
    fmt.Printf("AddressType => %+v\n", res.AddressType)
    fmt.Printf("District => %+v\n", res.District)
    fmt.Printf("AdsCategory => %+v\n", res.AdsCategory)
    fmt.Printf("AdsCategoryName => %+v\n", res.AdsCategoryName)
    fmt.Printf("IsProxy => %+v\n", res.IsProxy)

    fmt.Printf("Continent.Name => %+v\n", res.Continent.Name)
    fmt.Printf("Continent.Code => %+v\n", res.Continent.Code)
    fmt.Printf("Continent.Hemisphere => %+v\n", res.Continent.Hemisphere)
    fmt.Printf("Continent.Translation.Lang => %+v\n", res.Continent.Translation.Lang)
    fmt.Printf("Continent.Translation.Value => %+v\n", res.Continent.Translation.Value)

    fmt.Printf("Country.Name => %+v\n", res.Country.Name)
    fmt.Printf("Country.Alpha3Code => %+v\n", res.Country.Alpha3Code)
    fmt.Printf("Country.NumericCode => %+v\n", res.Country.NumericCode)
    fmt.Printf("Country.Demonym => %+v\n", res.Country.Demonym)
    fmt.Printf("Country.Flag => %+v\n", res.Country.Flag)
    fmt.Printf("Country.Capital => %+v\n", res.Country.Capital)
    fmt.Printf("Country.TotalArea => %+v\n", res.Country.TotalArea)
    fmt.Printf("Country.Population => %+v\n", res.Country.Population)
    fmt.Printf("Country.Currency.Code => %+v\n", res.Country.Currency.Code)
    fmt.Printf("Country.Currency.Name => %+v\n", res.Country.Currency.Name)
    fmt.Printf("Country.Currency.Symbol => %+v\n", res.Country.Currency.Symbol)
    fmt.Printf("Country.Language.Code => %+v\n", res.Country.Language.Code)
    fmt.Printf("Country.Language.Name => %+v\n", res.Country.Language.Name)
    fmt.Printf("Country.Tld => %+v\n", res.Country.Tld)
    fmt.Printf("Country.Translation.Lang => %+v\n", res.Country.Translation.Lang)
    fmt.Printf("Country.Translation.Value => %+v\n", res.Country.Translation.Value)

    fmt.Printf("Region.Name => %+v\n", res.Region.Name)
    fmt.Printf("Region.Code => %+v\n", res.Region.Code)
    fmt.Printf("Region.Translation.Lang => %+v\n", res.Region.Translation.Lang)
    fmt.Printf("Region.Translation.Value => %+v\n", res.Region.Translation.Value)

    fmt.Printf("City.Name => %+v\n", res.City.Name)
    fmt.Printf("City.Translation.Lang => %+v\n", res.City.Translation.Lang)
    fmt.Printf("City.Translation.Value => %+v\n", res.City.Translation.Value)

    fmt.Printf("TimeZoneInfo.Olson => %+v\n", res.TimeZoneInfo.Olson)
    fmt.Printf("TimeZoneInfo.CurrentTime => %+v\n", res.TimeZoneInfo.CurrentTime)
    fmt.Printf("TimeZoneInfo.GmtOffset => %+v\n", res.TimeZoneInfo.GmtOffset)
    fmt.Printf("TimeZoneInfo.IsDst => %+v\n", res.TimeZoneInfo.IsDst)
    fmt.Printf("TimeZoneInfo.Sunrise => %+v\n", res.TimeZoneInfo.Sunrise)
    fmt.Printf("TimeZoneInfo.Sunset => %+v\n", res.TimeZoneInfo.Sunset)

    fmt.Printf("Geotargeting.Metro => %+v\n", res.Geotargeting.Metro)

    fmt.Printf("Proxy.LastSeen => %+v\n", res.Proxy.LastSeen)
    fmt.Printf("Proxy.ProxyType => %+v\n", res.Proxy.ProxyType)
    fmt.Printf("Proxy.Threat => %+v\n", res.Proxy.Threat)
    fmt.Printf("Proxy.Provider => %+v\n", res.Proxy.Provider)
    fmt.Printf("Proxy.IsVpn => %+v\n", res.Proxy.IsVpn)
    fmt.Printf("Proxy.IsTor => %+v\n", res.Proxy.IsTor)
    fmt.Printf("Proxy.IsDataCenter => %+v\n", res.Proxy.IsDataCenter)
    fmt.Printf("Proxy.IsPublicProxy => %+v\n", res.Proxy.IsPublicProxy)
    fmt.Printf("Proxy.IsWebProxy => %+v\n", res.Proxy.IsWebProxy)
    fmt.Printf("Proxy.IsWebCrawler => %+v\n", res.Proxy.IsWebCrawler)
    fmt.Printf("Proxy.IsResidentialProxy => %+v\n", res.Proxy.IsResidentialProxy)
    fmt.Printf("Proxy.IsSpammer => %+v\n", res.Proxy.IsSpammer)
    fmt.Printf("Proxy.IsScanner => %+v\n", res.Proxy.IsScanner)
    fmt.Printf("Proxy.IsBotnet => %+v\n", res.Proxy.IsBotnet)
}

Remember to modify the above code to include your own IP2Location.io API key.
Then navigate to the test folder and run the below command to test the code.

go run test.go

If all goes well, you should see the output like below:

IP => 8.8.8.8
CountryCode => US
CountryName => United States of America
RegionName => California
CityName => Mountain View
Latitude => 37.38605
Longitude => -122.08385
ZipCode => 94035
TimeZone => -08:00
Asn => 15169
AS => Google LLC
Isp => Google LLC
Domain => google.com
NetSpeed => T1
IddCode => 1
AreaCode => 650
WeatherStationCode => USCA0746
WeatherStationName => Mountain View
Mcc => -
Mnc => -
MobileBrand => -
Elevation => 32
UsageType => DCH
AddressType => Anycast
District =>
AdsCategory =>
AdsCategoryName =>
IsProxy => false
Continent.Name => North America
Continent.Code => NA
Continent.Hemisphere => [north west]
Continent.Translation.Lang => en
Continent.Translation.Value => North America
Country.Name => United States of America
Country.Alpha3Code => USA
Country.NumericCode => 840
Country.Demonym => Americans
Country.Flag => https://cdn.ip2location.io/assets/img/flags/us.png
Country.Capital => Washington, D.C.
Country.TotalArea => 9826675
Country.Population => 331002651
Country.Currency.Code => USD
Country.Currency.Name => United States Dollar
Country.Currency.Symbol => $
Country.Language.Code => EN
Country.Language.Name => English
Country.Tld => us
Country.Translation.Lang => en
Country.Translation.Value => United States of America
Region.Name => California
Region.Code => US-CA
Region.Translation.Lang => en
Region.Translation.Value => California
City.Name => Mountain View
City.Translation.Lang => en
City.Translation.Value => Mountain View
TimeZoneInfo.Olson => America/Los_Angeles
TimeZoneInfo.CurrentTime => 2023-11-20T23:52:20-08:00
TimeZoneInfo.GmtOffset => -28800
TimeZoneInfo.IsDst => false
TimeZoneInfo.Sunrise => 06:54
TimeZoneInfo.Sunset => 16:54
Geotargeting.Metro => 807
Proxy.LastSeen => 0
Proxy.ProxyType =>
Proxy.Threat =>
Proxy.Provider =>
Proxy.IsVpn => false
Proxy.IsTor => false
Proxy.IsDataCenter => false
Proxy.IsPublicProxy => false
Proxy.IsWebProxy => false
Proxy.IsWebCrawler => false
Proxy.IsResidentialProxy => false
Proxy.IsSpammer => false
Proxy.IsScanner => false
Proxy.IsBotnet => false

For the purpose of checking if the IP belongs to a VPN or a residential proxy, all you need to do is check the Proxy.IsVPN or the Proxy.IsResidentialProxy inside the result struct. After that, if either is true, then you can decide if you want to block that IP if you’re interested in geofencing. Or if you’re running an online store, you can choose to block them to prevent possible fraudulent transactions.

Conclusion

As you can see from the extensive amount of data returned, you can do a whole lot with the IP2Location.io Go SDK. For instance, you can audit your network security, screen website visitors, prevent fraudsters from making purchases or block online attackers. If you’re curious about what the IP2Location.io API has to offer, you can sign up for the free API plan to start with.

For more tutorials, please visit IP2Location IP Gelocation

Where can I find free IP Geolocation API?

Where can I get free IP Geolocation database?

Using C# to check for proxy and VPN with IP2Location.io geolocation API

IP2Location — Fri, 24 Nov 2023 08:22:11 +0000

Intro

The IP2Location.io API is a great way to query an IP address to find its geolocation and proxy data. For C# developers, there is the IP2Location.io .NET SDK which is a wrapper for the API. By using this SDK, there is no need to manually parse and deserialize the JSON result into a usable form. In this article, we’ll explore why you need geolocation and proxy detection. We’ll also show a sample code for using the IP2Location.io .NET SDK to query the IP and get the resulting data.

IP geolocation usage scenarios

If you’re not familiar with IP geolocation, it’s basically the process of mapping an IP address to physical locations. Developers can use geolocation databases or API to check what is the country, region, city, ISP, time zone and so much more just based on the IP address. Common usage scenarios involving geolocation would be showing localized contents on websites, targeted advertising, multilingual websites, auto-filling forms with basic location details, etc. Modern websites heavily rely on IP geolocation to perform most of their functionalities.

Detect proxy usage like VPN and residential proxy

The benefit of using the IP2Location.io API is that the data also includes whether the IP belongs to a proxy server. Being able to tell if the user browsing a website is using a proxy server is a necessity, especially for e-commerce websites. Fraudsters commonly hide their IP geolocation using proxy servers like VPN or residential proxy servers when making online purchases with stolen cards. This makes it harder for online stores to check whether the order is a fraudulent one. Fraud detection normally checks IP geolocation countries vs. the shipping or billing address. By using a proxy that is located in the same country as the address, fraudsters can potentially slip through the fraud checking mechanism. Hence, it’s vital for websites to have proxy server detection.

Prerequisites for running the code

There are some requirements before you can run the example code that we’ll show below.

Sign up for an IP2Location.io API key at https://www.ip2location.io/pricing if you don’t have one. The free plan comes with basic geolocation data which can be useful to get started.
You’ll need Visual Studio 2022 or later to compile and run our code.

Let’s create a new C# project for our demo

Open up your Visual Studio and click on Create a new project.
Then select Console App as in the screenshot below and click Next.

Next, we’ll call our project DemoIP2LocationIO as below and click Next.

After that, we’ll select .NET 7.0 as our framework and click Create.

Now, we should see the editor like below.

Before we edit the code, install the NuGet package which contains the IP2Location.io .NET SDK that will allow us to use the IP2Location.io API. We’ll also need to install the JSON parser.

In the Visual Studio menu, click on Tools -> NuGet Package Manager -> Manage NuGet Packages for Solution, then click on the Newtonsoft.Json package to install it.

Do the same for the IP2Location.io package. You may need to search “IP2Location.io” to find it.

Now, let’s modify the existing code with our code

Let’s replace the code in Program.cs with the below code. Remember to edit the code to use your IP2Location.io API key that you’ve signed up for above.

using Newtonsoft.Json;
using IP2LocationIOComponent;

// Configures IP2Location.io API key
Configuration Config = new()
{
    ApiKey = "YOUR_API_KEY"
};

IPGeolocation IPL = new(Config);
string IP = "8.8.8.8";
string Lang = "en"; // the language param is only available with Plus and Security plans

// Lookup ip address geolocation data
var MyTask = IPL.Lookup(IP, Lang); // async API call

try
{
    var MyObj = MyTask.Result;

    // pretty-print JSON
    Console.WriteLine(JsonConvert.SerializeObject(MyObj, Formatting.Indented));

    // individual fields
    Console.WriteLine("ip: {0}", MyObj["ip"]);
    Console.WriteLine("country_code: {0}", MyObj["country_code"]);
    Console.WriteLine("country_name: {0}", MyObj["country_name"]);
    Console.WriteLine("region_name: {0}", MyObj["region_name"]);
    Console.WriteLine("city_name: {0}", MyObj["city_name"]);
    Console.WriteLine("latitude: {0}", MyObj["latitude"]);
    Console.WriteLine("longitude: {0}", MyObj["longitude"]);
    Console.WriteLine("zip_code: {0}", MyObj["zip_code"]);
    Console.WriteLine("time_zone: {0}", MyObj["time_zone"]);
    Console.WriteLine("asn: {0}", MyObj["asn"]);
    Console.WriteLine("as: {0}", MyObj["as"]);
    if (MyObj["isp"] != null) Console.WriteLine("isp: {0}", MyObj["isp"]);
    if (MyObj["domain"] != null) Console.WriteLine("domain: {0}", MyObj["domain"]);
    if (MyObj["net_speed"] != null) Console.WriteLine("net_speed: {0}", MyObj["net_speed"]);
    if (MyObj["idd_code"] != null) Console.WriteLine("idd_code: {0}", MyObj["idd_code"]);
    if (MyObj["area_code"] != null) Console.WriteLine("area_code: {0}", MyObj["area_code"]);
    if (MyObj["weather_station_code"] != null) Console.WriteLine("weather_station_code: {0}", MyObj["weather_station_code"]);
    if (MyObj["weather_station_name"] != null) Console.WriteLine("weather_station_name: {0}", MyObj["weather_station_name"]);
    if (MyObj["mcc"] != null) Console.WriteLine("mcc: {0}", MyObj["mcc"]);
    if (MyObj["mnc"] != null) Console.WriteLine("mnc: {0}", MyObj["mnc"]);
    if (MyObj["mobile_brand"] != null) Console.WriteLine("mobile_brand: {0}", MyObj["mobile_brand"]);
    if (MyObj["elevation"] != null) Console.WriteLine("elevation: {0}", MyObj["elevation"]);
    if (MyObj["usage_type"] != null) Console.WriteLine("usage_type: {0}", MyObj["usage_type"]);
    if (MyObj["address_type"] != null) Console.WriteLine("address_type: {0}", MyObj["address_type"]);
    if (MyObj["district"] != null) Console.WriteLine("district: {0}", MyObj["district"]);
    if (MyObj["ads_category"] != null) Console.WriteLine("ads_category: {0}", MyObj["ads_category"]);
    if (MyObj["ads_category_name"] != null) Console.WriteLine("ads_category_name: {0}", MyObj["ads_category_name"]);
    Console.WriteLine("is_proxy: {0}", MyObj["is_proxy"]);

    if (MyObj["continent"] != null)
    {
        var Continent = MyObj["continent"];
        Console.WriteLine("continent => name: {0}", Continent["name"]);
        Console.WriteLine("continent => code: {0}", Continent["code"]);
        Console.WriteLine("continent => hemisphere: {0}", Continent["hemisphere"]);
        Console.WriteLine("continent => translation => lang: {0}", Continent["translation"]["lang"]);
        Console.WriteLine("continent => translation => value: {0}", Continent["translation"]["value"]);
    }

    if (MyObj["country"] != null)
    {
        var Country = MyObj["country"];
        Console.WriteLine("country => name: {0}", Country["name"]);
        Console.WriteLine("country => alpha3_code: {0}", Country["alpha3_code"]);
        Console.WriteLine("country => numeric_code: {0}", Country["numeric_code"]);
        Console.WriteLine("country => demonym: {0}", Country["demonym"]);
        Console.WriteLine("country => flag: {0}", Country["flag"]);
        Console.WriteLine("country => capital: {0}", Country["capital"]);
        Console.WriteLine("country => total_area: {0}", Country["total_area"]);
        Console.WriteLine("country => population: {0}", Country["population"]);
        Console.WriteLine("country => tld: {0}", Country["tld"]);

        Console.WriteLine("country => currency => code: {0}", Country["currency"]["code"]);
        Console.WriteLine("country => currency => name: {0}", Country["currency"]["name"]);
        Console.WriteLine("country => currency => symbol: {0}", Country["currency"]["symbol"]);

        Console.WriteLine("country => language => code: {0}", Country["language"]["code"]);
        Console.WriteLine("country => language => name: {0}", Country["language"]["name"]);

        Console.WriteLine("country => translation => lang: {0}", Country["translation"]["lang"]);
        Console.WriteLine("country => translation => value: {0}", Country["translation"]["value"]);
    }

    if (MyObj["region"] != null)
    {
        var Region = MyObj["region"];
        Console.WriteLine("region => name: {0}", Region["name"]);
        Console.WriteLine("region => code: {0}", Region["code"]);

        Console.WriteLine("region => translation => lang: {0}", Region["translation"]["lang"]);
        Console.WriteLine("region => translation => value: {0}", Region["translation"]["value"]);
    }

    if (MyObj["city"] != null)
    {
        var City = MyObj["city"];
        Console.WriteLine("city => name: {0}", City["name"]);

        Console.WriteLine("city => translation => lang: {0}", City["translation"]["lang"]);
        Console.WriteLine("city => translation => value: {0}", City["translation"]["value"]);
    }

    if (MyObj["time_zone_info"] != null)
    {
        var TimeZone = MyObj["time_zone_info"];
        Console.WriteLine("time_zone_info => olson: {0}", TimeZone["time_zone_info"]);
        Console.WriteLine("time_zone_info => current_time: {0}", TimeZone["current_time"]);
        Console.WriteLine("time_zone_info => gmt_offset: {0}", TimeZone["gmt_offset"]);
        Console.WriteLine("time_zone_info => is_dst: {0}", TimeZone["is_dst"]);
        Console.WriteLine("time_zone_info => sunrise: {0}", TimeZone["sunrise"]);
        Console.WriteLine("time_zone_info => sunset: {0}", TimeZone["sunset"]);
    }

    if (MyObj["geotargeting"] != null)
    {
        var GeoTarget = MyObj["geotargeting"];
        Console.WriteLine("geotargeting => metro: {0}", GeoTarget["metro"]);
    }

    if (MyObj["proxy"] != null)
    {
        var Proxy = MyObj["proxy"];
        Console.WriteLine("proxy => last_seen: {0}", Proxy["last_seen"]);
        Console.WriteLine("proxy => proxy_type: {0}", Proxy["proxy_type"]);
        Console.WriteLine("proxy => threat: {0}", Proxy["threat"]);
        Console.WriteLine("proxy => provider: {0}", Proxy["provider"]);
        Console.WriteLine("proxy => is_vpn: {0}", Proxy["is_vpn"]);
        Console.WriteLine("proxy => is_tor: {0}", Proxy["is_tor"]);
        Console.WriteLine("proxy => is_data_center: {0}", Proxy["is_data_center"]);
        Console.WriteLine("proxy => is_public_proxy: {0}", Proxy["is_public_proxy"]);
        Console.WriteLine("proxy => is_web_proxy: {0}", Proxy["is_web_proxy"]);
        Console.WriteLine("proxy => is_web_crawler: {0}", Proxy["is_web_crawler"]);
        Console.WriteLine("proxy => is_residential_proxy: {0}", Proxy["is_residential_proxy"]);
        Console.WriteLine("proxy => is_spammer: {0}", Proxy["is_spammer"]);
        Console.WriteLine("proxy => is_scanner: {0}", Proxy["is_scanner"]);
        Console.WriteLine("proxy => is_botnet: {0}", Proxy["is_botnet"]);
    }
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Run the code to query geolocation and proxy data for the 8.8.8.8 IP address. You should see the below output. There are 2 sections in the output. In our code, we will output the raw JSON result in pretty-print format. This is so you can see what is actually returned by the API. Then we will output the individual fields if they exist. For the individual fields, any that is shown with “=>” means it’s a nested field.

NOTE: Our example is using the Security plan so we have access to all the fields. If you’re not subscribed to the Security plan, you will see less data.

{
  "ip": "8.8.8.8",
  "country_code": "US",
  "country_name": "United States of America",
  "region_name": "California",
  "city_name": "Mountain View",
  "latitude": 37.38605,
  "longitude": -122.08385,
  "zip_code": "94035",
  "time_zone": "-08:00",
  "asn": "15169",
  "as": "Google LLC",
  "isp": "Google LLC",
  "domain": "google.com",
  "net_speed": "T1",
  "idd_code": "1",
  "area_code": "650",
  "weather_station_code": "USCA0746",
  "weather_station_name": "Mountain View",
  "mcc": "-",
  "mnc": "-",
  "mobile_brand": "-",
  "elevation": 32,
  "usage_type": "DCH",
  "address_type": "Anycast",
  "continent": {
    "name": "North America",
    "code": "NA",
    "hemisphere": [
      "north",
      "west"
    ],
    "translation": {
      "lang": "en",
      "value": "North America"
    }
  },
  "district": "Santa Clara County",
  "country": {
    "name": "United States of America",
    "alpha3_code": "USA",
    "numeric_code": 840,
    "demonym": "Americans",
    "flag": "https://cdn.ip2location.io/assets/img/flags/us.png",
    "capital": "Washington, D.C.",
    "total_area": 9826675,
    "population": 331002651,
    "currency": {
      "code": "USD",
      "name": "United States Dollar",
      "symbol": "$"
    },
    "language": {
      "code": "EN",
      "name": "English"
    },
    "tld": "us",
    "translation": {
      "lang": "en",
      "value": "United States of America"
    }
  },
  "region": {
    "name": "California",
    "code": "US-CA",
    "translation": {
      "lang": "en",
      "value": "California"
    }
  },
  "city": {
    "name": "Mountain View",
    "translation": {
      "lang": "en",
      "value": "Mountain View"
    }
  },
  "time_zone_info": {
    "olson": "America/Los_Angeles",
    "current_time": "2023-11-23T09:32:39+08:00",
    "gmt_offset": -28800,
    "is_dst": false,
    "sunrise": "06:56",
    "sunset": "16:53"
  },
  "geotargeting": {
    "metro": "807"
  },
  "ads_category": "IAB19-11",
  "ads_category_name": "Data Centers",
  "is_proxy": false,
  "proxy": {
    "last_seen": 22,
    "proxy_type": "DCH",
    "threat": "-",
    "provider": "-",
    "is_vpn": false,
    "is_tor": false,
    "is_data_center": true,
    "is_public_proxy": false,
    "is_web_proxy": false,
    "is_web_crawler": false,
    "is_residential_proxy": false,
    "is_spammer": false,
    "is_scanner": false,
    "is_botnet": false
  }
}
ip: 8.8.8.8
country_code: US
country_name: United States of America
region_name: California
city_name: Mountain View
latitude: 37.38605
longitude: -122.08385
zip_code: 94035
time_zone: -08:00
asn: 15169
as: Google LLC
isp: Google LLC
domain: google.com
net_speed: T1
idd_code: 1
area_code: 650
weather_station_code: USCA0746
weather_station_name: Mountain View
mcc: -
mnc: -
mobile_brand: -
elevation: 32
usage_type: DCH
address_type: Anycast
district: Santa Clara County
ads_category: IAB19-11
ads_category_name: Data Centers
is_proxy: False
continent => name: North America
continent => code: NA
continent => hemisphere: [
  "north",
  "west"
]
continent => translation => lang: en
continent => translation => value: North America
country => name: United States of America
country => alpha3_code: USA
country => numeric_code: 840
country => demonym: Americans
country => flag: https://cdn.ip2location.io/assets/img/flags/us.png
country => capital: Washington, D.C.
country => total_area: 9826675
country => population: 331002651
country => tld: us
country => currency => code: USD
country => currency => name: United States Dollar
country => currency => symbol: $
country => language => code: EN
country => language => name: English
country => translation => lang: en
country => translation => value: United States of America
region => name: California
region => code: US-CA
region => translation => lang: en
region => translation => value: California
city => name: Mountain View
city => translation => lang: en
city => translation => value: Mountain View
time_zone_info => olson:
time_zone_info => current_time: 23/11/2023 9:32:39 AM
time_zone_info => gmt_offset: -28800
time_zone_info => is_dst: False
time_zone_info => sunrise: 06:56
time_zone_info => sunset: 16:53
geotargeting => metro: 807
proxy => last_seen: 22
proxy => proxy_type: DCH
proxy => threat: -
proxy => provider: -
proxy => is_vpn: False
proxy => is_tor: False
proxy => is_data_center: True
proxy => is_public_proxy: False
proxy => is_web_proxy: False
proxy => is_web_crawler: False
proxy => is_residential_proxy: False
proxy => is_spammer: False
proxy => is_scanner: False
proxy => is_botnet: False

With such an extensive amount of data returned by the IP2Location.io API, C# developers can easily determine what country, region and city the website visitor is from. In addition, IP addresses from logs can be checked against the geolocation and proxy data to make sure that there is no unauthorized access to networks or servers. Marketing analytics can also be enriched with such detailed geolocation to enable better use of the marketing resources.

As for online merchants, it is very important to check whether the is_vpn or is_residential_proxy nested field is true. If either is true, merchants need to decide if they wish to block such IP addresses from accessing the services or making purchases.

Conclusion

It is that easy to integrate the IP2Location.io API and its comprehensive data into any C# projects. The benefits reaped from such data can help to boost revenue, block frauds and strengthen organizational security posture.