What python libraries can tell me approximate location and time zone given an IP address?

It is not a Python lib. But http://ipinfodb.com/ provides a webservice that can be easily wrapped by Python code with urllib for example.

http://api.ipinfodb.com/v3/ip-city/?key=<your_api_key>&ip=74.125.45.100
http://api.ipinfodb.com/v3/ip-country/?key=<your_api_key>&ip=74.125.45.100

You need to request a free API key. See the API doc for details.

You may find these modules useful: MaxMind’s GeoIP and its pure version, as well pytz.

I’m using ipinfodb, is free (registration required) and has 2 queries per sec limit and seems to be accurate.

try:

http://api.ipinfodb.com/v3/ip-city/?key={{API_KEY}}&ip=190.188.221.244&timezone=true

returns:

OK;;190.188.221.244;AR;ARGENTINA;BUENOS AIRES;LA PLATA;-;-34.931;-57.949;-03:00

“Geopy makes it easy for developers to locate the coordinates of addresses, cities, countries, and landmarks across the globe using third-party geocoders and other data sources, such as wikis.

geopy currently includes support for six geocoders: Google Maps, Yahoo! Maps, Windows Local Live (Virtual Earth), geocoder.us, GeoNames, MediaWiki pages (with the GIS extension), and Semantic MediaWiki pages. “

I posted this in another question that had been buried, but linked here:

#!/usr/bin/env python 
from urllib2 import urlopen
from contextlib import closing
import json

# Automatically geolocate the connecting IP
url = 'http://freegeoip.net/json/'
try:
    with closing(urlopen(url)) as response:
        location = json.loads(response.read())
        print(location)
        location_city = location['city']
        location_state = location['region_name']
        location_country = location['country_name']
        location_zip = location['zipcode']
except:
    print("Location could not be determined automatically")

Send HTTP GET requests to: freegeoip.net/{format}/{ip_or_hostname} to receive a JSON output that Python can parse.

I get the following JSON keys, which should be sufficient for what you are needing:

• ip
• country_code
• country_name
• region_code
• region_name
• city
• zipcode
• latitude
• longitude
• metro_code
• area_code

Found https://freegeoip.net/; python sample below.

import requests

FREEGEOPIP_URL = 'http://freegeoip.net/json/'

SAMPLE_RESPONSE = """{
    "ip":"108.46.131.77",
    "country_code":"US",
    "country_name":"United States",
    "region_code":"NY",
    "region_name":"New York",
    "city":"Brooklyn",
    "zip_code":"11249",
    "time_zone":"America/New_York",
    "latitude":40.645,
    "longitude":-73.945,
    "metro_code":501
}"""


def get_geolocation_for_ip(ip):
    url = '{}/{}'.format(FREEGEOPIP_URL, ip)

    response = requests.get(url)
    response.raise_for_status()

    return response.json()

IP API is also very nice way to do it.

import urllib

ip= '12.24.36.48'

url = 'http://ip-api.com/json/' + ip

req = urllib.request.Request(url)

out = urllib.request.urlopen(req).read()

I think freegeip is a good option. Below is the Python 3.4.2 code for getting location and time zone.

>>> import requests
>>> ip = '141.70.111.66'   
>>> url = 'http://freegeoip.net/json/'+ip
>>> r = requests.get(url)
>>> js = r.json()
>>> js['country_code']
'DE'
>>> js['country_name']
'Germany'
>>> js['time_zone']
'Europe/Berlin'

Install the Python module pygeoip

C:>pip install pygeoip

Download the binary file of GeoLite City from here: https://dev.maxmind.com/geoip/legacy/geolite/

Then:

>>> import pygeoip
>>> g = pygeoip.GeoIP('GeoLiteCity.dat')
>>> ip = '134.222.199.110' #just an example
>>> g.record_by_addr(ip)['latitude']
52.38239999999999
>>> g.record_by_addr(ip)['longitude']
4.899499999999989
>>> g.record_by_addr(ip)['time_zone']
'Europe/Amsterdam'

Contrary to the freegeoip solution I see in the other comments, this option has no limits on the number of IPs per hour, can be used locally without Internet connection, and the geocoordinates are generally more accurate.

You could use requests to make a call to my service https://ipdata.co

import requests

ip = '1.1.1.1'
response = requests.get('https://api.ipdata.co/{}'.format(ip)).json()
response['time_zone']

Maxmind has an official api package that integrates with their geoip web service or geolite databases.
You'll have to either download their free geolite database or create a free trial account.

If you register for an account you'll get $5 in promotional credit (paid queries cost about $0.0001 each). Login to your account, click on 'My License Key' and create a license key.

Then install the package:

$ pip install geoip2

And test the api:

Test function adapted from the docs

import geoip2.webservice

account_id = 1 # enter your real account id here
api_key = "enter your real api/license key here"

TEST_IP = '128.101.101.101'


def lookup_ip(ip=TEST_IP):
    # This creates a Client object that can be reused across requests.
    client = geoip2.webservice.Client(account_id, api_key)

    # Replace "insights" with the method corresponding to the web service
    # that you are using, e.g., "country", "city".
    response = client.insights(ip)

    print("country iso code: {0}".format(response.country.iso_code))

    print("country name: {0}".format(response.country.name))

    print("subdivisions most specific name: {0}".format(response.subdivisions.most_specific.name))
    print("subdivisions most specific iso code: {0}".format(response.subdivisions.most_specific.iso_code))

    print("city name: {0}".format(response.city.name))

    print("postal code:{0}".format(response.postal.code))

    print("coordinates: ({0}, {1})".format(response.location.latitude, response.location.longitude))

    return response


if __name__ == "__main__":
    resp = lookup_ip()
    input("")

I had replied to similar question at here: How to find location with IP address in Python?, so let me put the answer on here also with the installation step.

Assuming that you got the ip address already, you can try to use the IP2Location Python Library to get the user location. First of all you would have to install the IP2Location Python Library. You can install it by using PyPi: pip install IP2Location, or download the release from here: https://github.com/chrislim2888/IP2Location-Python/releases. After that, you can use the library along with the database downloaded from IP2Location or IP2Location LITE like this:

import os
import IP2Location

database = IP2Location.IP2Location(os.path.join("data", "IP2LOCATION-LITE-DB11.BIN"))

rec = database.get_all(ip)

print(rec.country_short)
print(rec.country_long)
print(rec.region)
print(rec.city)
print(rec.isp)  
print(rec.latitude)
print(rec.longitude)            
print(rec.domain)
print(rec.zipcode)
print(rec.timezone)
print(rec.netspeed)
print(rec.idd_code)
print(rec.area_code)
print(rec.weather_code)
print(rec.weather_name)
print(rec.mcc)
print(rec.mnc)
print(rec.mobile_brand)
print(rec.elevation)
print(rec.usage_type)

Depends on your requirement, for example if you want to get the user's country name and region name, you can do this:

import os
import IP2Location

database = IP2Location.IP2Location(os.path.join("data", "IP2LOCATION-LITE-DB11.BIN"))

rec = database.get_all(ip)

user_country = rec.country_long
user_region = rec.region

For more details, you can visit here: https://www.ip2location.com/developers/python

Github link: https://github.com/chrislim2888/IP2Location-Python

IPinfo provides you with both the location information and timezone on one single API call. They also have a Python Library.

Method 1: Using the API with requests

import requests

# here I have genearated this IP address randomly
ip_address = "60.213.153.57"

# get your token from your IPinfo account dashboard
token = ""

# using f-string here. Use any method to create the URL
url = f"https://ipinfo.io/{ip_address}?token={token}"

# json response after the IP lookup
response = requests.get(url).json()

The response will look like this:

{
  "ip": "60.213.153.57",
  "city": "Tianjin",
  "region": "Tianjin",
  "country": "CN",
  "loc": "39.1422,117.1767",
  "org": "AS4837 CHINA UNICOM China169 Backbone",
  "timezone": "Asia/Shanghai"
}

You can get your location and timezone from the response.

>>> response['city']
"Tianjin"

>>> response['country']
"CN"

>>> response['timezone']
"Asia/Shanghai"

Method 2: Using the Python library

The IPinfo Python library makes this process much easier. Install it with pip. IPinfo Python Documentation

# install with `pip install ipinfo`
import ipinfo

# initialize handler with access token
access_token = "insert_your_token_here"
handler = ipinfo.getHandler(access_token)

ip_address = '216.239.36.21'
details = handler.getDetails(ip_address)

From the details you can now find individual information

>>> details.city
'Mountain View'

>>> details.timezone
'America/Los_Angeles'