Häufig gestellte Fragen

Wir bieten zwei verschiedene Datenbankformate (CSV und BIN).

Das erste Datenbankformat ist als Comma Separated Values ​​(CSV) bekannt. Es ist eine Textdatei und alle Felder werden durch ein Komma mit doppeltem Anführungszeichen in jedem Feld getrennt. Jede einzelne Zeile ist ein Datenbankeintrag.

Das zweite Datenbankformat ist als Binär (BIN) bekannt. Es ist eine Binärdatei mit Datenbankinformationen. Entwickler greifen über die IP2Location-API von auf die BIN-Dateien zu, die in mehreren Sprachen verfügbar sind.

Sie können die IP2Location LITE-Datenbank mithilfe des-Downloadclients oder gängiger HTTP-Anwendungen wie wget oder curl automatisieren. Wir aktualisieren IP2Location-Datenbanken am ersten Tag des Kalendermonats. Bitte laden Sie die Datenbank einmal im Monat an einem zufälligen Tag ab der ersten Woche des Kalendermonats herunter, um eine Überlastung des Netzwerks zu vermeiden. Wir werden jedes LITE-Konto deaktivieren, wenn eine gemeinsame Nutzung von Konten oder ein massiver Download festgestellt wird.

./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

Die IP-Adresse (IPV4) ist in 4 Unterblöcke unterteilt. Jeder Unterblock hat eine andere Gewichtsnummer, die jeweils mit 256 betrieben wird. Die IP-Nummer wird in der Datenbank verwendet, da die Suche zwischen mehreren Nummern in einer Datenbank effizienter ist.

Die Anfangs- und End-IP-Nummer werden nach folgender Formel berechnet:

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

Beispielcode in verschiedenen Programmiersprachen

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.

Beispielcode in verschiedenen Programmiersprachen

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)), "")

Die IP-Adresse (IPv6) ist in 8 Gruppen mit vier hexadezimalen Ziffern mit einem Doppelpunkt als Gruppentrennzeichen unterteilt. Jede Gruppe hat eine andere Gewichtsnummer, die jeweils von 65536 unterstützt wird. Die IP-Nummer wird in der Datenbank verwendet, da die Suche zwischen mehreren Nummern in einer Datenbank effizienter ist.

Wie konvertiere ich eine IP-Nummer in eine IPv6-Adresse?

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

Beispielcode in verschiedenen Programmiersprachen

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.

Beispielcode in verschiedenen Programmiersprachen

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

Konvertieren Sie zunächst die IP-Adresse in das IP-Nummernformat. Durchsuchen Sie die IP-Länderdatenbank mit der IP-Nummer, um einen Datensatz zu finden, dessen IP-Nummer zwischen der Anfangs-IP-Nummer und der End-IP-Nummer liegt.

Beispielsweise lautet die IP-Adresse "72.77.138.60" in der IP-Nummer "1213041212". Es stimmte mit dem folgenden Recordset in der Datenbank überein.

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

Der IP2Location zeigt das Feld "-" im Land an, wenn der IP-Adressbereich noch keinem Land zugeordnet ist. Es wird auch als reservierter IP-Adressbereich bezeichnet.

Importieren Sie diese Datenbank zunächst in MSSQL, MS-ACCESS, PL / SQL, MYSQL oder ein anderes RDMS. Verwenden Sie eine SQL-Abfrage, um das passende Recordset abzurufen.

Beispiel für eine SQL-Abfrage (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]

Beispiel für eine SQL-Abfrage (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])

Ohne Proxy-Erkennung
<%
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, wir senden die Benachrichtigung per E-Mail, wenn das Update im Downloadbereich verfügbar ist.

Weitere Informationen finden Sie unter Funktionsvergleich.

Das Eigentum an IP-Adressen wechselt von Zeit zu Zeit den Besitzer. Daher muss jedes Jahr ein kleiner Prozentsatz der IP-Adressblöcke aktualisiert werden. Unsere Vollversionsdatenbank wird monatlich aktualisiert, um sicherzustellen, dass sie immer korrekt ist.

Sie können ip2location.com besuchen und den Kauf tätigen. Alternativ können Sie auch im Kontobereich ein Upgrade von der LITE Edition durchführen. Wir generieren ein eindeutiges Login / Passwort, damit Sie die Datenbank ein Jahr lang herunterladen können, nachdem wir Ihre Bestellung bearbeitet haben.

Sie erhalten Ihr Login und Passwort sofort nach Autorisierung der Zahlung per E-Mail. Sie können Ihre Anmeldeinformationen verwenden, um die Datenbank jederzeit von unserer Website herunterzuladen. Die Datenbank ist in einem ZIP-komprimierten Format, um Bandbreite und Downloadzeit zu sparen.

Sie können eine Kopie der LITE-Datenbank mit Ihrer Anwendung mit Namensnennung weitergeben. Sie müssen jedoch alle Benutzer informieren, um sich für eine individuelle Lizenz in https: //lite.ip2location.com zu registrieren, um monatliche Updates herunterzuladen. Das Datenbank-Repository eines Drittanbieters ist nicht zulässig.

IP2Location bietet keinen Kundensupport für kostenlose IP2Location LITE-Datenbanken. Wenn Sie programmierbezogene Fragen zur Verwendung dieser Datenbanken haben, die in den häufig gestellten Fragen nicht beantwortet werden, empfehlen wir Ihnen, Fragen zu Stapelüberlauf zu stellen.

Sign Up Pop Out

Geolocate Your Visitors Location

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