We provide two different database formats (CSV and BIN).
The first database format is known as Comma Separated Values (CSV). It is a text file and all fields are separated by a comma with double quote in each field. Each individual row is a database record.
The second database format is known as Binary (BIN). It is a binary file with database information. Developers access to the BIN files using IP2Location API available in multiple languages.
You can automate the IP2Location LITE database using download client or common HTTP applications such as wget or curl . We update IP2Location databases on the first day of the calendar month. Please download the database once a month during a random day from the first week of calendar month to avoid network congestion. We will disable any LITE account if account sharing or massive download is detected.
./download.pl -package DB11LITE -token DOWNLOAD_TOKEN
Package Code | Description |
---|---|
DB11LITE | IP2Location LITE DB11 - IPV4 - CSV |
DB11LITEBIN | IP2Location LITE DB11 - IPV4 - BIN |
DB11LITEIPV6 | IP2Location LITE DB11 - IPV6 - CSV |
DB11LITEBINIPV6 | IP2Location LITE DB11 - IPV6 - BIN |
IP address (IPV4) is divided into 4 sub-blocks. Each sub-block has a different weight number each powered by 256. IP number is being used in the database because it is more efficient to search between a range of numbers in a database.
The Beginning IP number and Ending IP Number are calculated based on the following formula:
IP Number = 16777216*w + 65536*x + 256*y + z (1)
where
IP Address = w.x.y.z
For example, if the IP address is "202.186.13.4", then its IP Number will be "3401190660", based on the formula (1).
IP Address = 202.186.13.4
So, w = 202, x = 186, y = 13 and z = 4
IP Number = 16777216*202 + 65536*186 + 256*13 + 4
= 3388997632 + 12189696 + 3328 + 4
= 3401190660
Function Dot2LongIP (ByVal DottedIP)
Dim i, pos
Dim PrevPos, num
If DottedIP = "" Then
Dot2LongIP = 0
Else
For i = 1 To 4
pos = InStr(PrevPos + 1, DottedIP, ".", 1)
If i = 4 Then
pos = Len(DottedIP) + 1
End If
num = Int(Mid(DottedIP, PrevPos + 1, pos - PrevPos - 1))
PrevPos = pos
Dot2LongIP = ((num Mod 256) * (256 ^ (4 - i))) + Dot2LongIP
Next
End If
End Function
function Dot2LongIP($IPaddr)
{
if ($IPaddr == "") {
return 0;
} else {
$ips = explode(".", "$IPaddr");
return ($ips[3] + $ips[2] * 256 + $ips[1] * 256 * 256 + $ips[0] * 256 * 256 * 256);
}
}
long Dot2LongIP(String ipstring) {
String[] ipAddressInArray = ipstring.split("\\.");
long result = 0;
long ip = 0;
for (int x = 3; x >= 0; x--) {
ip = Long.parseLong(ipAddressInArray[3 - x]);
result |= ip << (x << 3);
}
return result;
}
function Dot2LongIP(ipAddress)
{
if (arguments.ipAddress EQ "") {
return 0;
} else {
ips = ListToArray( arguments.ipAddress, "." );
return( ( 16777216 * ips[1] ) + ( 65536 * ips[2] ) + ( 256 * ips[3] ) + ips[4] );
}
}
public double Dot2LongIP(string DottedIP)
{
int i;
string [] arrDec;
double num = 0;
if (DottedIP == "") {
return 0;
} else {
arrDec = DottedIP.Split(".");
for (i = arrDec.Length - 1; i >= 0 ; i --) {
num += ((int.Parse(arrDec[i])%256) * Math.Pow(256 ,(3 - i )));
}
return num;
}
}
Public Function Dot2LongIP(ByVal DottedIP As String) As Double
Dim arrDec() As String
Dim i As Integer
Dim intResult As Long
If DottedIP = "" then
Dot2LongIP = 0
Else
arrDec = DottedIP.Split(".")
For i = arrDec.Length - 1 To 0 Step -1
intResult = intResult + ((Int(arrDec(i)) Mod 256) * Math.Pow(256, 3 -i))
Next
Dot2LongIP = intResult
End If
End function
use Socket;
sub dot2LongIP {
my $ip_address = shift(@_);
return unpack("N",inet_aton($ip_address));
}
require 'ipaddr'
def dot2LongIP(ip)
ipnum = IPAddr.new(ip)
return ipnum.to_i
end
import ipaddress
def dot2LongIP(ip):
return int(ipaddress.IPv4Address(ip))
uint32_t Dot2LongIP(char* ipstring)
{
uint32_t ip = inet_addr(ipstring);
uint8_t *ptr = (uint8_t *) &ip;
uint32_t a = 0;
if (ipstring != NULL) {
a = (uint8_t)(ptr[3]);
a += (uint8_t)(ptr[2]) * 256;
a += (uint8_t)(ptr[1]) * 256 * 256;
a += (uint8_t)(ptr[0]) * 256 * 256 * 256;
}
return a;
}
CREATE FUNCTION Dot2LongIP (ip text)
RETURNS bigint
BEGIN
DECLARE ipnum bigint;
SET ipnum = (SELECT INET_ATON(ip));
RETURN ipnum;
END
CREATE FUNCTION [dbo].[Dot2LongIP]( @IP VarChar(15) )
RETURNS BigInt
AS
BEGIN
DECLARE @ipA BigInt,
@ipB BigInt,
@ipC BigInt,
@ipD BigInt,
@ipE BigInt
SELECT @ipA = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipA) - 1 )
SELECT @ipB = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipB) - 1 )
SELECT @ipC = LEFT(@ip, PATINDEX('%.%', @ip) - 1 )
SELECT @ip = RIGHT(@ip, LEN(@ip) - LEN(@ipC) - 1 )
SELECT @ipD = @ip
SELECT @ipE = ( @ipA * 256*256*256 ) + ( @ipB * 256*256 ) + ( @ipC * 256 ) + @ipD
RETURN @ipE
END
CREATE OR REPLACE FUNCTION Dot2LongIP(text) RETURNS BIGINT AS '
SELECT
split_part($1,''.'',1)::int8*(256*256*256)+
split_part($1,''.'',2)::int8*(256*256)+
split_part($1,''.'',3)::int8*256+
split_part($1,''.'',4)::int8;'
LANGUAGE SQL;
Convert IPv4 IP Address to IP Number in Decimal Integer (IPv4 IP Address is in cell A1):
=((VALUE(LEFT(A1, FIND(".", A1)-1)))*256^3)+((VALUE(MID(A1, FIND(".", A1)+1, FIND(".", A1, FIND(".", A1)+1)-FIND(".", A1)-1)))*256^2)+((VALUE(MID(A1, FIND(".", A1, FIND(".", A1)+1)+1, FIND(".", A1, FIND(".", A1, FIND(".", A1)+1)+1)-FIND(".", A1, FIND(".", A1)+1)-1)))*256)+(VALUE(RIGHT(A1, LEN(A1)-FIND(".", A1, FIND(".", A1, FIND(".", A1)+1)+1))))
IP Address = w.x.y.z
To reverse IP number to IP address,
w = int ( IP Number / 16777216 ) % 256
x = int ( IP Number / 65536 ) % 256
y = int ( IP Number / 256 ) % 256
z = int ( IP Number ) % 256
where
%
is the modulus operator and
int
returns the integer part of the division.
Function Modulus(Value1, Value2)
Modulus = Value1 - (Int(Value1 / Value2) * Value2)
End Function
Function Long2DotIP (ByVal IPNum)
Long2DotIP = Modulus(Int(IPNum / 16777216), 256) & "." & Modulus(Int(IPNum / 65536), 256) & "." & Modulus(Int(IPNum / 256), 256) & "." & Modulus(IPNum, 256)
End Function
function Long2DotIP ($IPNum)
{
if ($IPNum == "") {
return "0.0.0.0";
} else {
return (($IPNum / 16777216) % 256) . "." . (($IPNum / 65536) % 256) . "." . (($IPNum / 256) % 256) . "." . ($IPNum % 256);
}
}
String Long2DotIP(long ipnum) {
String result = "";
result = ((ipnum / 16777216) % 256) + "." + ((ipnum / 65536) % 256) + "." + ((ipnum / 256) % 256) + "." + (ipnum % 256);
return result;
}
function Modulus(value1, value2) {
return arguments.value1 - (floor(arguments.value1 / arguments.value2) * arguments.value2);
}
function Long2DotIP(ipNum) {
return (Modulus(floor(arguments.ipNum / 16777216), 256)) & "." & (Modulus(floor(arguments.ipNum / 65536), 256)) & "." & (Modulus(floor(arguments.ipNum / 256), 256)) & "." & (Modulus(floor(arguments.ipNum), 256));
}
public string Long2DotIP(long IPNum)
{
string result = "";
result = ((IPNum / 16777216) % 256) + "." + ((IPNum / 65536) % 256) + "." + ((IPNum / 256) % 256) + "." + (IPNum % 256);
return result;
}
Public Function Long2DotIP(ByVal IPNum As Long) As String
Dim result As String = ""
result = (Int(IPNum / 16777216) Mod 256) & "." & (Int(IPNum / 65536) Mod 256) & "." & (Int(IPNum / 256) Mod 256) & "." & (IPNum Mod 256)
Return result
End Function
use Socket;
sub long2DotIP {
my $ip_number = shift(@_);
return inet_ntoa(pack("N*", $ip_number));
}
def long2DotIP(ipnum)
return ((ipnum / 16777216) % 256).to_s + "." + ((ipnum / 65536) % 256).to_s + "." + ((ipnum / 256) % 256).to_s + "." + (ipnum % 256).to_s
end
def long2DotIP(ipnum):
return str(int(ipnum / 16777216) % 256) + "." + str(int(ipnum / 65536) % 256) + "." + str(int(ipnum / 256) % 256) + "." + str(ipnum % 256)
char* Long2DotIP(uint32_t ipnum)
{
uint8_t bytes[4];
char* buf = malloc (sizeof (char) * 16);
bytes[0] = (ipnum >> 24) & 0xFF;
bytes[1] = (ipnum >> 16) & 0xFF;
bytes[2] = (ipnum >> 8) & 0xFF;
bytes[3] = ipnum & 0xFF;
snprintf(buf, (sizeof (char) * 16), "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);
return buf;
}
CREATE FUNCTION Long2DotIP (ipnum bigint)
RETURNS text
BEGIN
DECLARE ip text;
SET ip = (SELECT INET_NTOA(ipnum));
RETURN ip;
END
CREATE FUNCTION [dbo].[Long2DotIP]( @IPNum BigInt )
RETURNS VARCHAR(15)
AS
BEGIN
RETURN CAST(((@IPNum / 16777216) % 256) AS VARCHAR(3)) + + CAST(((@IPNum / 65536) % 256) AS VARCHAR(3)) + + CAST(((@IPNum / 256) % 256) AS VARCHAR(3)) + + CAST((@IPNum % 256) AS VARCHAR(3))
END
CREATE OR REPLACE FUNCTION Long2DotIP(BIGINT) RETURNS TEXT AS '
SELECT
CONCAT(($1 >> 24) % 256, ''.'', ($1 >> 16) % 256, ''.'', ($1 >> 8) % 256, ''.'', $1 % 256);'
LANGUAGE SQL;
Convert IP Number in Decimal Integer to IPv4 IP Address (Decimal Integer is in cell A1):
=IF(A1<>"", CONCATENATE(MOD(BITRSHIFT(A1, 24), 256), ".", MOD(BITRSHIFT(A1, 16), 256), ".", MOD(BITRSHIFT(A1, 8), 256), ".", MOD(A1, 256)), "")
IP address (IPv6) is divided into 8 groups of four hexadecimal digits with a colon as a group separator. Each group has a different weight number each powered by 65536. IP number is being used in the database because it is more efficient to search between a range of numbers in a database.
How do I convert an IP Number to an IPv6 Address?
IP Number = (65536^7)*a + (65536^6)*b + (65536^5)*c + (65536^4)*d + (65536^3)*e + (65536^2)*f + 65536*g + h (1)
where
IP Address = a:b:c:d:e:f:g:h
For example, if the IP address is "2001:0db8:0000:0042:0000:8a2e:0370:7334", then its IP Number will be "42540766411282594074389245746715063092", based on the formula (1).
IP Address (in hexadecimal) = 2001:0db8:0000:0042:0000:8a2e:0370:7334
IP Address (in decimal) = 8193:3512:0:66:0:35374:880:29492
IP Number = (65536^7)*8193 + (65536^6)*3512 + (65536^5)*0 + (65536^4)*66 + (65536^3)*0 + (65536^2)*35374 + 65536*880 + 29492
= 5192296858534827628530496329220096*8193 + 79228162514264337593543950336*3512 + 1208925819614629174706176*0 + 18446744073709551616*66 + 281474976710656*0 + 4294967296*35374 + 57671680 + 29492
= 42540488161975842760550356425300246528 + 278249306750096353628526353580032 + 0 + 1217485108864830406656 + 0 + 151930173128704 + 57671680 + 29492
= 42540766411282594074389245746715063092
function Dot2LongIP($ipv6) {
return (string) gmp_import(inet_pton($ipv6));
}
java.math.BigInteger Dot2LongIP(String ipv6) {
java.net.InetAddress ia = java.net.InetAddress.getByName(ipv6);
byte byteArr[] = ia.getAddress();
if (ia instanceof java.net.Inet6Address) {
java.math.BigInteger ipnumber = new java.math.BigInteger(1, byteArr);
return ipnumber;
}
}
function Dot2LongIP(ipv6)
{
if (arguments.ipv6 eq "") {
return 0;
} else {
IPV6Long = CreateObject("java","java.math.BigInteger");
IPV6NetAddress = CreateObject("java","java.net.InetAddress");
newIp = IPV6NetAddress.getByName(arguments.ipv6);
bytes = newIp.getAddress();
bigInt = IPV6Long.init(1, bytes).toString();
return bigInt;
}
}
public System.Numerics.BigInteger Dot2LongIP(string ipv6)
{
System.Net.IPAddress address;
System.Numerics.BigInteger ipnum;
if (System.Net.IPAddress.TryParse(ipv6, out address)) {
byte[] addrBytes = address.GetAddressBytes();
if (System.BitConverter.IsLittleEndian) {
System.Collections.Generic.List<byte> byteList = new System.Collections.Generic.List<byte>(addrBytes);
byteList.Reverse();
addrBytes = byteList.ToArray();
}
if (addrBytes.Length > 8) {
//IPv6
ipnum = System.BitConverter.ToUInt64(addrBytes, 8);
ipnum <<= 64;
ipnum += System.BitConverter.ToUInt64(addrBytes, 0);
} else {
//IPv4
ipnum = System.BitConverter.ToUInt32(addrBytes, 0);
}
return ipnum;
}
}
Public Function Dot2LongIP(ByVal ipv6 As String) As System.Numerics.BigInteger
Dim address As System.Net.IPAddress
Dim ipnum As System.Numerics.BigInteger
If System.Net.IPAddress.TryParse(ipv6, address) Then
Dim addrBytes() As Byte = address.GetAddressBytes()
If System.BitConverter.IsLittleEndian Then
Dim byteList As New System.Collections.Generic.List(Of Byte)(addrBytes)
byteList.Reverse()
addrBytes = byteList.ToArray()
End If
If addrBytes.Length > 8 Then
'IPv6
ipnum = System.BitConverter.ToUInt64(addrBytes, 8)
ipnum <<= 64
ipnum += System.BitConverter.ToUInt64(addrBytes, 0)
Else
'IPv4
ipnum = System.BitConverter.ToUInt32(addrBytes, 0)
End If
End If
Dot2LongIP = ipnum
End Function
use NetAddr::IP;
sub dot2LongIP {
my $ip_address = shift(@_);
my $ip_number = NetAddr::IP->new($ip_address) or die;
return $ip_number->bigint;
}
require 'ipaddr'
def dot2LongIP(ipv6)
ipnum = IPAddr.new(ipv6)
return ipnum.to_i
end
import ipaddress
def dot2LongIP(ipv6):
return int(ipaddress.IPv6Address(ipv6))
#include <arpa/inet.h>
#include <inttypes.h>
typedef unsigned __int128 uint128_t;
uint128_t Dot2LongIP(const char* ipv6) {
struct sockaddr_in6 sa;
inet_pton(AF_INET6, ipv6, &(sa.sin6_addr));
uint128_t ipnum = 0;
uint128_t octet = 0;
int i;
for (i = 0; i < (sizeof(sa.sin6_addr.s6_addr) / sizeof(sa.sin6_addr.s6_addr[0])); i++) {
octet = ((uint128_t)sa.sin6_addr.s6_addr[i] << ((uint128_t)(15 - i) * 8));
ipnum = ipnum + octet;
}
return ipnum;
}
IP Address = a:b:c:d:e:f:g:h
To reverse IP number to IP address,
a = int ( IP Number / (65536^7) ) % 65536
b = int ( IP Number / (65536^6) ) % 65536
c = int ( IP Number / (65536^5) ) % 65536
d = int ( IP Number / (65536^4) ) % 65536
e = int ( IP Number / (65536^3) ) % 65536
f = int ( IP Number / (65536^2) ) % 65536
g = int ( IP Number / 65536 ) % 65536
h = IP Number % 65536
where
%
is the modulus operator and
int
returns the integer part of the division.
NOTE: All parts need to be converted into hexadecimal to be part of the IPv6 address.
function Long2DotIP($integer) {
return inet_ntop(str_pad(gmp_export($integer), 16, "\0", STR_PAD_LEFT));
}
String Long2DotIP(String integer)
{
String ipstr = new java.math.BigInteger(integer).toString(16);
String padding = new String(new char[32 - ipstr.length()]).replace("\0", "0");
String retval = padding + ipstr;
retval = retval.replaceAll("(.{4})", "$1:").substring(0, 39);
return retval;
}
function Long2DotIP(integer)
{
if (arguments.integer eq "") {
return 0;
} else {
retval = "";
bigobj = CreateObject("java","java.math.BigInteger");
intval = bigobj.init(integer).toString(16);
padding = repeatstring("0", 32 - len(intval));
retval = padding & intval;
retval = rereplace(rereplace(retval, "(.{4})", "\1:", "ALL"), ":$", "");
return retval;
}
}
public string Long2DotIP(string bigint)
{
string retval = "";
System.Numerics.BigInteger intval = System.Numerics.BigInteger.Zero;
if (System.Numerics.BigInteger.TryParse(bigint, out intval)) {
retval = intval.ToString("x").PadLeft(32, '0');
char[] trimme = new[] { ':' };
retval = System.Text.RegularExpressions.Regex.Replace(retval, "(.{4})", "$1:").TrimEnd(trimme);
}
return retval;
}
Public Function Long2DotIP(ByVal bigint As String) As String
Dim retval As String = ""
Dim intval As System.Numerics.BigInteger = System.Numerics.BigInteger.Zero
If System.Numerics.BigInteger.TryParse(bigint, intval) Then
retval = intval.ToString("x").PadLeft(32, "0"c)
Dim trimme As Char() = {":"c}
retval = System.Text.RegularExpressions.Regex.Replace(retval, "(.{4})", "$1:").TrimEnd(trimme)
End If
Return retval
End Function
use Math::BigInt;
sub long2DotIP {
my $ipnumstr = shift(@_);
my $ipnum = Math::BigInt->new($ipnumstr);
my $iphex = $ipnum->as_hex();
$iphex =~ s/^0x//;
my $ipv6 = ('0' x (32 - length($iphex))) . $iphex;
$ipv6 =~ s/(.{4})/$1:/g;
$ipv6 =~ s/:$//;
return $ipv6;
}
def long2DotIP(integer)
return integer.to_s(16).rjust(32, '0').gsub(/(.{4})/, "\1:").sub(/:$/, "")
end
import re
def long2DotIP(integer):
retval = format(integer, 'x')
retval = retval.zfill(32)
retval = re.sub(r"(.{4})", r"\1:", retval)
retval = re.sub(r":$", "", retval)
return retval
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gmp.h>
char* Long2DotIP(char* ipnum)
{
mpz_t bigint;
char* buf = malloc (sizeof (char) * 33);
char* buf2 = malloc (sizeof (char) * 40);
int i = 0;
int parts = 8;
int partsize = 5;
char **arr;
arr = calloc(parts, sizeof *arr);
for (i = 0; i < parts; i++)
{
arr[i] = calloc(partsize, sizeof *arr[i]);
}
mpz_init_set_str(bigint, ipnum, 10);
gmp_snprintf(buf, (sizeof (char) * 33), "%032Zx", bigint);
for (i = 0; i < parts; i++)
{
memcpy(arr[i], buf + (i * 4), 4);
}
snprintf(buf2, (sizeof (char) * 40), "%s:%s:%s:%s:%s:%s:%s:%s", arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7]);
free(buf);
free(arr);
return buf2;
}
Firstly, convert the IP address to IP number format. Search IP-Country Database using IP number to match a record that has the IP Number between the Beginning IP Number and the Ending IP Number.
For example, IP Address "72.77.138.60" is "1213041212" in IP Number. It matched the following recordset in the database.
"1213041208","1213041215","US","UNITED STATES"
The IP2Location will display the "-" in country field when the IP address range is still unallocated to any countries. It is also known as reserved IP address range.
First, import this database into your MSSQL, MS-ACCESS, PL/SQL, MYSQL or other RDMS. Use an SQL query to get the matching recordset.
Example of SQL Query (MSSQL)
SELECT [COUNTRY NAME COLUMN], [REGION NAME COLUMN], [CITY NAME COLUMN], [LATITUDE COLUMN], [LONGITUDE COLUMN], [ZIP CODE COLUMN], [TIME ZONE COLUMN], [ISP COLUMN], [DOMAIN NAME COLUMN], [NETSPEED COLUMN], [IDD CODE COLUMN], [AREA CODE COLUMN], [WEATHER STATION CODE COLUMN], [WEATHER STATION NAME COLUMN], [MCC COLUMN], [MNC COLUMN], [BRAND NAME COLUMN]
FROM [IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE TABLE]
WHERE [SEARCH IP NO] BETWEEN [IP FROM COLUMN] AND [IP TO COLUMN]
Example of SQL Query (MYSQL)
SELECT [COUNTRY NAME COLUMN], [REGION NAME COLUMN], [CITY NAME COLUMN], [LATITUDE COLUMN], [LONGITUDE COLUMN], [ZIP CODE COLUMN], [TIME ZONE COLUMN], [ISP COLUMN], [DOMAIN NAME COLUMN], [NETSPEED COLUMN], [IDD CODE COLUMN], [AREA CODE COLUMN], [WEATHER STATION CODE COLUMN], [WEATHER STATION NAME COLUMN], [MCC COLUMN], [MNC COLUMN], [BRAND NAME COLUMN]
FROM [IP-COUNTRY-REGION-CITY-LATITUDE-LONGITUDE-ZIPCODE-TIMEZONE-ISP-DOMAIN-NETSPEED-AREACODE-WEATHER-MOBILE TABLE]
WHERE ([IP FROM COLUMN] <= [SEARCH IP NO]) AND ([IP TO COLUMN] <= [SEARCH IP NO])
<%
ipaddress = Request.ServerVariables("REMOTE_ADDR")
%>
<?
$ipaddress = getenv('REMOTE_ADDR');
?>
<%
String ipaddress = request.getRemoteAddr();
%>
<CFCOMPONENT>
<CFSET ipaddress="#CGI.Remote_Addr#">
</CFCOMPONENT>
Public Function IpAddress()
IpAddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
End Function
<%
ipaddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
if ipaddress = "" then
ipaddress = Request.ServerVariables("REMOTE_ADDR")
end if
%>
<?
if (getenv('HTTP_X_FORWARDED_FOR')) {
$ipaddress = getenv('HTTP_X_FORWARDED_FOR');
} else {
$ipaddress = getenv('REMOTE_ADDR');
}
?>
<%
if (request.getHeader("X_FORWARDED_FOR") == null) {
String ipaddress = request.getRemoteAddr();
} else {
String ipaddress = request.getHeader("X_FORWARDED_FOR");
}
%>
<CFCOMPONENT>
<CFIF #CGI.HTTP_X_Forwarded_For# EQ "">
<CFSET ipaddress="#CGI.Remote_Addr#">
<CFELSE>
<CFSET ipaddress="#CGI.HTTP_X_Forwarded_For#">
</CFIF>
</CFCOMPONENT>
public string IpAddress()
{
string strIp;
strIp = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (strIp == null) {
strIp = Request.ServerVariables["REMOTE_ADDR"];
}
return strIp;
}
Public Function IpAddress()
Dim strIp As String
strIp = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
If strIp = "" Then
strIp = Request.ServerVariables("REMOTE_ADDR")
End If
IpAddress = strIp
End Function
Yes, we will deliver the notification via email when the update is available in the download area.
Please visit Features Comparison for details.
Ownership of IP addresses change hands from time to time. Therefore, a small percentage of IP address blocks needs to be updated every year. Our full version database is updated monthly to make sure it is always accurate.
You can visit ip2location.com and make the purchase. Alternatively, you can also upgrade from LITE edition under account area. We will generate an unique login/password to allow you to download the database for one year after we have processed your order.
You will receive your login and password through email immediately after payment is authorized. You can use your credentials to download the database from our website at anytime. The database is in a ZIP compressed format to save your bandwidth and downloading time.
You can redistribute one copy of the LITE database with your application with attribution. However, you need to inform all users to register for an individual license in https://lite.ip2location.com to download monthly updates. Third party database repository is not allowed.
IP2Location does not provide customer support for free IP2Location LITE databases. If you have programming related questions on how to use these databases that is not answered in FAQs, we suggest you asking on Stack Overflow .
Enhance your applications with essential geolocation data by using our FREE databases.