IP2Location.io Haskell SDK (ip2location-io) is a Haskell library for retrieving IPv4 and IPv6 geolocation, network, and IP intelligence data through the IP2Location.io API. It also provides domain WHOIS lookup, domain/URL helpers, and hosted-domain lookup. The library lets Haskell applications access IP and domain information without manually constructing API requests.
Quick links: Get an API key · Developer documentation · API reference · GitHub repository
- IPv4 and IPv6 geolocation: Retrieve country, region, district, city, latitude, longitude, and ZIP/postal code.
- Network and ASN information: Access ASN, AS name, ISP, associated domain, connection speed, and usage type when available.
- Time zone and localization data: Inspect time zone information, available DST details, and translated location names (Plus and Security plans).
- Proxy and security signals: Access plan-dependent proxy, VPN, Tor, data center, crawler, and fraud-related fields.
- Additional IP intelligence: Retrieve available mobile carrier data (MCC/MNC), country metadata, advertising categories, and other attributes.
- Domain WHOIS lookup: Access domain registration dates, registrar details, nameservers, status, and available contacts.
- Domain and URL utilities: Extract domain names from URLs and get domain extensions.
- Hosted domains: Retrieves a page of hosted-domain results for an IP address.
Plan availability: Fields vary by subscription plan and queried address. Optional values can be absent even when a field is supported. See API plans and the Haskell API reference.
The official Haskell API reference describes these operations:
| Module / function | Description |
|---|---|
Configuration.open(apiKey) |
Creates the configuration object with the API key. |
IPGeolocation.lookUpIP config ip language |
Retrieves geolocation and eligible network/security attributes for an IPv4 or IPv6 address. |
DomainWhois.lookUpDomain config domain |
Retrieves WHOIS data for a domain name. |
DomainWhois.getDomainName url |
Extracts the domain name from a URL. |
DomainWhois.getDomainExtension value |
Retrieves the domain extension from a domain or URL. |
HostedDomain.lookUpHosted config ip page |
Retrieves a page of hosted-domain results for an IP address. |
IP2Location.io provides keyless geolocation access through its REST API and a Free plan with an API key:
| API service | Keyless (no API key) | Free plan (with API key) |
|---|---|---|
| IP Geolocation API | 1,000 queries/day | 50,000 queries/month |
| Domain WHOIS API | — | 500 queries/month |
| Hosted Domain API | — | 50 queries/month |
- Keyless access: Limited keyless IP geolocation queries are available directly through the REST API; the Haskell SDK documentation requires an API key and does not describe a keyless SDK mode. The keyless allowance resets at 00:00 UTC.
- Free plan: Create an API key to use the monthly allowances shown above.
- Attribution: The keyless and Free offerings require attribution; consult the pricing page for current terms.
- Paid plans: Higher limits and additional data fields are described on the pricing page.
For authentication and rate-limit details, see the IP Geolocation REST API documentation.
- A working Haskell compiler (GHC) and Cabal.
- The
ip2location-ioHaskell package and its dependencies, resolved by Cabal. The package manifest specifies dependencies includingaeson,http-client, andhttp-client-tls. - An IP2Location.io API key for the SDK examples.
- Network connectivity to the relevant IP2Location.io services.
The package manifest specifies the Haskell2010 language standard and a compatible base range. Check the current manifest for compiler compatibility instead of assuming all GHC releases are supported.
The official Haskell quickstart documents installation with Cabal:
cabal install ip2location-ioFor an application project, declare ip2location-io as a dependency in your .cabal project configuration so its modules are available when building your program.
For the examples below, use an API key. The official samples place "YOUR_API_KEY" directly in the source; to avoid committing a credential, the quickstart below reads it from an environment variable instead.
Linux / macOS terminal:
export IP2LOCATION_API_KEY='YOUR_API_KEY'Windows Command Prompt:
set IP2LOCATION_API_KEY=YOUR_API_KEYCreate Main.hs with a minimal version of the official IP geolocation example:
import Configuration
import qualified IPGeolocation as IPG
import System.Environment (lookupEnv)
main :: IO ()
main = do
maybeKey <- lookupEnv "IP2LOCATION_API_KEY"
case maybeKey of
Nothing -> putStrLn "Set the IP2LOCATION_API_KEY environment variable."
Just apikey -> do
config <- open apikey
result <- IPG.lookUpIP config "8.8.8.8" ""
case result of
IPG.IPError err ->
putStrLn $ "ERROR: " ++ IPG.error_message (IPG.error err)
IPG.IPResponse response -> do
putStrLn $ "IP: " ++ IPG.ip response
putStrLn $ "Country: " ++ IPG.country_name response
putStrLn $ "City: " ++ IPG.city_name response
putStrLn $ "ASN: " ++ IPG.asn responseThe empty third argument ("") disables the optional translated-location-name request. The SDK returns a value that is handled with IPG.IPError or IPG.IPResponse, as shown in its official documentation.
Build and run Main.hs using your Cabal project setup (with ip2location-io declared as a dependency). For example, inside an executable Cabal project:
cabal runResponse attributes and their availability depend on your plan and the IP address. See the Haskell geolocation field reference.
The documented Haskell examples use pattern matching to distinguish a successful result from an API error, and accessor functions to read response fields. Some optional values are represented with Maybe and can be handled with case, maybe, or other standard Haskell constructs.
The examples below are individual snippets. Unless otherwise stated, they assume you have imported Configuration, created config using open apikey, and are inside an IO action (such as main).
The third argument to IPG.lookUpIP is a language code. Translations for continent, country, region, and city names are available on Plus and Security plans. The official example uses a blank string when translation is not requested.
import qualified IPGeolocation as IPG
-- Inside main, after creating config:
result <- IPG.lookUpIP config "8.8.8.8" "es"
case result of
IPG.IPError err -> putStrLn $ "ERROR: " ++ IPG.error_message (IPG.error err)
IPG.IPResponse response ->
putStrLn $ "Country: " ++ IPG.country_name responseASN and AS name appear directly on the documented geolocation response. ISP data may be absent under some plans, so use maybe for that optional field.
import qualified IPGeolocation as IPG
result <- IPG.lookUpIP config "8.8.8.8" ""
case result of
IPG.IPError err -> putStrLn $ "ERROR: " ++ IPG.error_message (IPG.error err)
IPG.IPResponse response -> do
putStrLn $ "ASN: " ++ IPG.asn response
putStrLn $ "AS: " ++ IPG.as response
putStrLn $ "ISP: " ++ maybe "NOT_SUPPORTED" id (IPG.isp response)Security data is plan-dependent. The official geolocation sample checks whether the nested proxy object is present before reading its fields.
import qualified IPGeolocation as IPG
result <- IPG.lookUpIP config "8.8.8.8" ""
case result of
IPG.IPError err -> putStrLn $ "ERROR: " ++ IPG.error_message (IPG.error err)
IPG.IPResponse response -> do
putStrLn $ "Is proxy: " ++ show (IPG.is_proxy response)
case IPG.proxy response of
Nothing -> putStrLn "Proxy details unavailable."
Just prx -> do
putStrLn $ "VPN: " ++ show (IPG.is_vpn prx)
putStrLn $ "Tor: " ++ show (IPG.is_tor prx)Treat these indicators as supporting signals rather than proof of malicious activity.
The official WHOIS example uses DomainWhois.lookUpDomain with the configuration object and domain name:
import qualified DomainWhois as DW
import qualified DomainWhois as Regist (Registrar(..))
result <- DW.lookUpDomain config "example.com"
case result of
DW.WhoisError err -> putStrLn $ "ERROR: " ++ DW.error_message (DW.error err)
DW.WhoisResponse response -> do
putStrLn $ "Domain: " ++ DW.domain response
putStrLn $ "Created: " ++ DW.create_date response
putStrLn $ "Expires: " ++ DW.expire_date response
let registrarObj = DW.registrar response
putStrLn $ "Registrar: " ++ Regist.name registrarObjWHOIS contact details can be unavailable or redacted. Refer to the WHOIS response field reference for the fields documented by this SDK.
These utilities follow the official Haskell examples and do not require a network lookup:
import qualified DomainWhois as DW
putStrLn $ DW.getDomainName "https://www.example.com/exe"
putStrLn $ DW.getDomainExtension "example.com"The Haskell documentation shows these two utilities; unlike some other language SDKs, it does not document Punycode conversion helpers here.
The official hosted-domain example requests a specific result page, starting at 1:
import qualified HostedDomain as HD
result <- HD.lookUpHosted config "8.8.8.8" 1
case result of
HD.HostedError err -> putStrLn $ "ERROR: " ++ HD.error_message (HD.error err)
HD.HostedResponse response -> do
putStrLn $ "IP: " ++ HD.ip response
putStrLn $ "Total domains: " ++ show (HD.total_domains response)
putStrLn $ "Page: " ++ show (HD.page response)
putStrLn $ "Total pages: " ++ show (HD.total_pages response)
putStrLn $ "Domains: " ++ show (HD.domains response)Use page 2, 3, and so on for additional pages when available.
- Module cannot be found: Make sure
ip2location-iois a declared dependency of the executable you are building. A system-levelcabal installalone may not make a library import available to every project. - Missing optional values: The SDK documentation uses
Maybefor fields such asispandproxy. HandleNothingrather than assuming every plan returns every field. - API errors: Handle the
IPError,WhoisError, andHostedErrorconstructors shown in the official examples, and check your API key, quota, and requested service.
- Application localization: Adapt regional content or preferred-language suggestions using approximate IP location.
- Network and traffic analysis: Attach country, ASN, and available ISP attributes to server/application events.
- Security review: Use eligible proxy, VPN, Tor, and fraud indicators as part of broader risk assessment.
- Domain research: Review WHOIS registration dates, registrars, domain status, and nameservers.
- Hosting research: Investigate domains associated with an IP address.
- Haskell SDK quickstart and official sample codes
- Haskell SDK API reference and response fields
- Official Haskell GitHub repository
- Haskell package manifest and dependencies
- IP2Location.io API plans and query limits
- IP Geolocation API authentication and rate limits
- Report an SDK issue or request a feature
- API and account support
Licensed under the MIT License. See LICENSE.