Veel Gestelde Vragen

We bieden twee verschillende database-indelingen (CSV en BIN).

De eerste database-indeling staat bekend als Comma Separated Values ​​(CSV). Het is een tekstbestand en alle velden worden gescheiden door een komma met dubbele aanhalingstekens in elk veld. Elke individuele rij is een databaserecord.

Het tweede databaseformaat staat bekend als Binair (BIN). Het is een binair bestand met database-informatie. Ontwikkelaars hebben toegang tot de BIN-bestanden met behulp van IP2Location API die beschikbaar is in meerdere talen.

U kunt de IP2Location LITE-database automatiseren met downloadclient of veelgebruikte HTTP-applicaties zoals wget of curl. We werken de IP2Location-databases bij op de eerste dag van de kalendermaand. Download de database eenmaal per maand op een willekeurige dag vanaf de eerste week van de kalendermaand om netwerkcongestie te voorkomen. We zullen elk LITE-account uitschakelen als het delen van accounts of massale downloads wordt gedetecteerd.

./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-adres (IPV4) is onderverdeeld in 4 subblokken. Elk subblok heeft een ander gewichtsnummer, elk aangedreven door 256. IP-nummer wordt gebruikt in de database omdat het efficiënter is om te zoeken tussen een reeks nummers in een database.

Het begin-IP-nummer en het eind-IP-nummer worden berekend op basis van de volgende formule:

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

Voorbeeldcode in verschillende programmeertalen

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.

Voorbeeldcode in verschillende programmeertalen

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-adres (IPv6) is onderverdeeld in 8 groepen van vier hexadecimale cijfers met een dubbele punt als groepscheidingsteken. Elke groep heeft een ander gewichtsnummer, elk aangedreven door 65536. IP-nummer wordt gebruikt in de database omdat het efficiënter is om te zoeken tussen een reeks nummers in een database.

Hoe converteer ik een IP-nummer naar een IPv6-adres?

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

Voorbeeldcode in verschillende programmeertalen

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.

Voorbeeldcode in verschillende programmeertalen

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;
}

Converteer eerst het IP-adres naar het IP-nummerformaat. Zoek in IP-landdatabase met behulp van het IP-nummer om een ​​record te vinden dat het IP-nummer heeft tussen het begin-IP-nummer en het eind-IP-nummer.

IP-adres "72.77.138.60" is bijvoorbeeld "1213041212" in IP-nummer. Het kwam overeen met de volgende recordset in de database.

"1213041208","1213041215","US","UNITED STATES"

De IP2Location geeft de "-" weer in het landveld als het IP-adresbereik nog niet aan een land is toegewezen. Het wordt ook wel het gereserveerde IP-adresbereik genoemd.

Importeer deze database eerst in uw MSSQL, MS-ACCESS, PL / SQL, MYSQL of andere RDMS. Gebruik een SQL-query om de overeenkomende recordset op te halen.

Voorbeeld van 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]

Voorbeeld van 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])

Zonder proxydetectie
<%
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

Ja, we sturen de melding via e-mail wanneer de update beschikbaar is in het downloadgedeelte.

Bezoek Functievergelijking voor details.

Het eigendom van IP-adressen wisselt van tijd tot tijd van eigenaar. Daarom moet elk jaar een klein percentage IP-adresblokken worden bijgewerkt. Onze volledige versiedatabase wordt maandelijks bijgewerkt om ervoor te zorgen dat deze altijd correct is.

U kunt ip2location.com bezoeken en de aankoop doen. Als alternatief kunt u ook upgraden vanaf de LITE-editie onder het accountgedeelte. We genereren een unieke login / wachtwoord waarmee u de database een jaar lang kunt downloaden nadat we uw bestelling hebben verwerkt.

U ontvangt uw login en wachtwoord per e-mail onmiddellijk nadat de betaling is geautoriseerd. U kunt uw gegevens gebruiken om de database op elk moment van onze website te downloaden. De database is in een gecomprimeerd ZIP-formaat om uw bandbreedte en downloadtijd te besparen.

U kunt één exemplaar van de LITE-database opnieuw distribueren met uw applicatie met attributie. U moet echter alle gebruikers informeren om zich te registreren voor een individuele licentie in https: //lite.ip2location.com om maandelijkse updates te downloaden. Databaserepository van derden is niet toegestaan.

IP2Location biedt geen klantenondersteuning voor gratis IP2Location LITE-databases. Als je programmeergerelateerde vragen hebt over het gebruik van deze databases die niet worden beantwoord in FAQ's, raden we je aan om dit te stellen op Stack Overflow.

Sign Up Pop Out

Geolocate Your Visitors Location

Enhance your applications with essential geolocation data by using our FREE databases.