BranchesTags

Repository files navigation

IPLocate geolocation client for Python

PyPI versionPython SupportLicense: MIT

A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:

  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine

See what information we can provide for your IP address.

Getting started

You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.

Installation

pip install python-iplocate

Quick start

Synchronous client

fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")

Asynchronous client

importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())

Get your own IP address information

# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")

Get the country for an IP address

result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")

Get the currency code for a country by IP address

result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")

Get the calling code for a country by IP address

result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")

Authentication

Get your free API key from IPLocate.io, and pass it when creating the client:

client=IPLocateClient(api_key="your-api-key")

Examples

IP address geolocation lookup

fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")

Check for VPN/Proxy Detection

result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")

ASN and network information

result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")

Using with different IP address types

importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)

Custom configuration

importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)

Context managers

# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)

Response structure

The LookupResponse object contains all available data:

@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None

Fields marked as Optional may be None if data is not available.

Error handling

fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")

Common API errors:

  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)

Async/await support

The library provides full async support with AsyncIPLocateClient:

importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())

API reference

For complete API documentation, visit iplocate.io/docs.

Requirements

  • Python 3.8+
  • httpx >= 0.24.0

Development

Install development dependencies:

pip install -e ".[dev]"

Run tests:

pytest

Run type checking:

mypy iplocate

Format code:

black iplocate tests
isort iplocate tests

License

This project is licensed under the MIT License - see the LICENSE file for details.

About IPLocate.io

Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.

We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.

About

IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API

www.iplocate.io

Topics

ip-addressip-address-geolocationip-geolocationip-to-countrypython

Resources

Readme
MIT license
Activity
Custom properties

Stars

2 stars

Watchers

0 watching

Forks

1 fork
Report repository

Releases

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
IPLocate geolocation client for Python
PyPI versionPython SupportLicense: MIT
A Python client for the IPLocate.io geolocation API. Look up detailed geolocation and threat intelligence data for any IP address:
  • IP geolocation: IP to country, IP to city, IP to region/state, coordinates, timezone, postal code
  • ASN information: Internet service provider, network details, routing information
  • Privacy & threat detection: VPN, proxy, Tor, hosting provider detection
  • Company information: Business details associated with IP addresses - company name, domain, type (ISP/hosting/education/government/business)
  • Abuse contact: Network abuse reporting information
  • Hosting detection: Cloud provider and hosting service detection using our proprietary hosting detection engine
See what information we can provide for your IP address.
Getting started
You can make 1,000 free requests per day with a free account. For higher plans, check out API pricing.
Installation
pip install python-iplocate
Quick start
Synchronous client
fromiplocateimportIPLocateClient# Create a client with your API key# Get your free API key from https://iplocate.io/signupclient=IPLocateClient(api_key="your-api-key")
# Look up an IP addressresult=client.lookup("8.8.8.8")
print(f"IP: {result.ip}")
ifresult.country:
print(f"Country: {result.country}")
ifresult.city:
print(f"City: {result.city}")
# Check privacy flagsprint(f"Is VPN: {result.privacy.is_vpn}")
print(f"Is Proxy: {result.privacy.is_proxy}")
Asynchronous client
importasynciofromiplocateimportAsyncIPLocateClientasyncdefmain():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(f"Country: {result.country}")
asyncio.run(main())
Get your own IP address information
# Look up your own IP address (no IP parameter)result=client.lookup()
print(f"Your IP: {result.ip}")
Get the country for an IP address
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
Get the currency code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Currency: {result.currency_code}")
Get the calling code for a country by IP address
result=client.lookup("203.0.113.1")
print(f"Calling code: {result.calling_code}")
Authentication
Get your free API key from IPLocate.io, and pass it when creating the client:
client=IPLocateClient(api_key="your-api-key")
Examples
IP address geolocation lookup
fromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
result=client.lookup("203.0.113.1")
print(f"Country: {result.country} ({result.country_code})")
ifresult.latitudeandresult.longitude:
print(f"Coordinates: {result.latitude:.4f}, {result.longitude:.4f}")
Check for VPN/Proxy Detection
result=client.lookup("192.0.2.1")
ifresult.privacy.is_vpn:
print("This IP is using a VPN")
ifresult.privacy.is_proxy:
print("This IP is using a proxy")
ifresult.privacy.is_tor:
print("This IP is using Tor")
ASN and network information
result=client.lookup("8.8.8.8")
ifresult.asn:
print(f"ASN: {result.asn.asn}")
print(f"ISP: {result.asn.name}")
print(f"Network: {result.asn.route}")
Using with different IP address types
importipaddressfromiplocateimportIPLocateClientclient=IPLocateClient(api_key="your-api-key")
# String IPresult1=client.lookup("8.8.8.8")
# ipaddress objectsipv4=ipaddress.IPv4Address("8.8.8.8")
result2=client.lookup(ipv4)
ipv6=ipaddress.IPv6Address("2001:4860:4860::8888")
result3=client.lookup(ipv6)
Custom configuration
importhttpxfromiplocateimportIPLocateClient, AsyncIPLocateClient# Custom timeout and base URLclient=IPLocateClient(
api_key="your-api-key",
timeout=60.0,
base_url="https://custom-endpoint.com/api"
)
# Custom HTTP clientcustom_http_client=httpx.Client(timeout=60.0)
client=IPLocateClient(
api_key="your-api-key",
http_client=custom_http_client
)
# Async with custom clientasync_http_client=httpx.AsyncClient(timeout=60.0)
async_client=AsyncIPLocateClient(
api_key="your-api-key", http_client=async_http_client
)
Context managers
# SynchronouswithIPLocateClient(api_key="your-api-key") asclient:
result=client.lookup("8.8.8.8")
print(result.country)
# AsynchronousasyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
result=awaitclient.lookup("8.8.8.8")
print(result.country)
Response structure
The LookupResponse object contains all available data:
@dataclassclassLookupResponse:
ip: strprivacy: Privacycountry: Optional[str] =Nonecountry_code: Optional[str] =Noneis_eu: bool=Falsecity: Optional[str] =Nonecontinent: Optional[str] =Nonelatitude: Optional[float] =Nonelongitude: Optional[float] =Nonetime_zone: Optional[str] =Nonepostal_code: Optional[str] =Nonesubdivision: Optional[str] =Nonecurrency_code: Optional[str] =Nonecalling_code: Optional[str] =Nonenetwork: Optional[str] =Noneasn: Optional[ASN] =Nonecompany: Optional[Company] =Nonehosting: Optional[Hosting] =Noneabuse: Optional[Abuse] =None
Fields marked as Optional may be None if data is not available.
Error handling
fromiplocateimportIPLocateClientfromiplocate.exceptionsimport (
APIError, RateLimitError, AuthenticationError, InvalidIPError
)
client=IPLocateClient(api_key="your-api-key")
try:
result=client.lookup("8.8.8.8")
exceptInvalidIPErrorase:
print(f"Invalid IP address: {e.ip}")
exceptAuthenticationError:
print("Invalid API key")
exceptRateLimitError:
print("Rate limit exceeded")
exceptAPIErrorase:
print(f"API error ({e.status_code}): {e.message}")
Common API errors:
  • InvalidIPError: Invalid IP address format
  • AuthenticationError: Invalid API key (HTTP 403)
  • NotFoundError: IP address not found (HTTP 404)
  • RateLimitError: Rate limit exceeded (HTTP 429)
  • APIError: Other API errors (HTTP 500, etc.)
Async/await support
The library provides full async support with AsyncIPLocateClient:
importasynciofromiplocateimportAsyncIPLocateClientasyncdeflookup_multiple_ips():
asyncwithAsyncIPLocateClient(api_key="your-api-key") asclient:
# Concurrent lookupstasks= [
client.lookup("8.8.8.8"),
client.lookup("1.1.1.1"),
client.lookup("208.67.222.222")
]
results=awaitasyncio.gather(*tasks)
forresultinresults:
print(f"{result.ip}: {result.country}")
asyncio.run(lookup_multiple_ips())
API reference
For complete API documentation, visit iplocate.io/docs.
Requirements
  • Python 3.8+
  • httpx >= 0.24.0
Development
Install development dependencies:
pip install -e ".[dev]"
Run tests:
pytest
Run type checking:
mypy iplocate
Format code:
black iplocate tests
isort iplocate tests
License
This project is licensed under the MIT License - see the LICENSE file for details.
About IPLocate.io
Since 2017, IPLocate has set out to provide the most reliable and accurate IP address data.
We process 50TB+ of data to produce our comprehensive IP geolocation, IP to company, proxy and VPN detection, hosting detection, ASN, and WHOIS data sets. Our API handles over 15 billion requests a month for thousands of businesses and developers.
About
 IP to country, IP to city, VPN/hosting/threat detection with the Python library for the IPLocate.io API 
www.iplocate.io
Topics
ip-addressip-address-geolocationip-geolocationip-to-countrypython
Resources
Readme
MIT license
Activity
Custom properties
Stars
2 stars
Watchers
0 watching
Forks
1 fork
Report repository
Releases
Used by
Contributors
Languages