Telize Getting Started: IP Geolocation API (2026)

Getting started overview

Integrating the Telize IP Geolocation API involves a few core steps: account creation, API key retrieval, and making an initial authenticated request. Telize provides a RESTful API that delivers geolocation data for IP addresses through standard HTTP GET requests. The process is designed for straightforward implementation, supporting use cases such as website personalization, fraud detection, and content geo-targeting by converting IP addresses into location details like country, city, and coordinates.

The Telize API supports a free tier for initial development and testing, allowing up to 1,000 requests per day without charge. For higher volumes or commercial applications, paid plans are available, starting at $9.99 per month for 250,000 requests. This guide will walk through the essential steps to get the Telize API operational quickly, from registration to a successful first API call.

Here's a quick reference table outlining the getting started process:

Create an account and get keys

To access the Telize IP Geolocation API, you must first create an account. This account provides access to the API key necessary for authenticating your requests. Follow these steps to register and retrieve your API key:

1. Navigate to the Telize Website: Open your web browser and go to the Telize official homepage.
2. Sign Up/Register: Look for a 'Sign Up' or 'Register' button, typically located in the top right corner of the page. Click on it to initiate the registration process.
3. Provide Account Details: You will be prompted to enter your email address and create a password. Ensure you use a valid email address as it may be used for verification.
4. Complete Registration: Follow any additional on-screen instructions, which might include email verification or agreeing to terms of service.
5. Access Dashboard: Once registration is complete and verified, log in to your new Telize account. You will be redirected to your personal dashboard.
6. Locate API Key: Within your dashboard, there will be a section dedicated to API keys or credentials. Your unique API key will be displayed there. It's often a string of alphanumeric characters. Copy this key, as it will be required for every API request you make. Treat your API key like a password to prevent unauthorized usage, as recommended for securing API keys in cloud services.

Telize uses a single API key for authentication across all its services. This key identifies your account and tracks your usage against your daily request limit or subscribed plan.

Your first request

After obtaining your API key, you can make your first request to the Telize IP Geolocation API. The API is designed to be straightforward, accepting HTTP GET requests. For this example, we'll use a public IP address (e.g., 8.8.8.8, Google's public DNS server) to demonstrate the request and expected response.

API Endpoint Structure

The base URL for the Telize API is https://api.telize.com/geoip/. You append the IP address you want to query and your API key to this base URL.

General Request Format:

GET https://api.telize.com/geoip/{ip_address}?apikey={your_api_key}

Replace {ip_address} with the target IP address and {your_api_key} with the key obtained from your Telize dashboard.

Example Request (cURL)

Using cURL is a common way to test REST APIs from the command line. Replace YOUR_API_KEY with your actual Telize API key.

curl "https://api.telize.com/geoip/8.8.8.8?apikey=YOUR_API_KEY"

Example Request (JavaScript)

Telize officially supports a JavaScript SDK. Here's how you might make a request using the fetch API in a web environment:

const API_KEY = 'YOUR_API_KEY'; // Replace with your actual API key
const IP_ADDRESS = '8.8.8.8'; // Or use a dynamic IP address

fetch(`https://api.telize.com/geoip/${IP_ADDRESS}?apikey=${API_KEY}`)
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error! Status: ${response.status}`);
    }
    return response.json();
  })
  .then(data => {
    console.log('Geolocation Data:', data);
    // Process the data here
    console.log(`Country: ${data.country}`);
    console.log(`City: ${data.city}`);
  })
  .catch(error => {
    console.error('Error fetching geolocation data:', error);
  });

Expected Response

A successful request will return a JSON object containing various geolocation details. The exact fields may vary, but common ones include:

{
  "ip": "8.8.8.8",
  "country": "United States",
  "country_code": "US",
  "continent": "North America",
  "continent_code": "NA",
  "city": "Mountain View",
  "region": "California",
  "region_code": "CA",
  "zip": "94043",
  "latitude": 37.422,
  "longitude": -122.084,
  "timezone": "America/Los_Angeles",
  "isp": "Google LLC",
  "organization": "Google LLC",
  "asn": "AS15169",
  "currency": {
    "code": "USD",
    "name": "United States Dollar"
  }
}

This response confirms that your API key is valid and the request was processed successfully by the Telize service. For detailed information on all possible response fields, refer to the Telize API documentation.

Common next steps

After successfully making your first request, consider these common next steps to further integrate Telize into your application:

1. Error Handling: Implement robust error handling in your application. The API may return various HTTP status codes (e.g., 400 for bad request, 401 for unauthorized, 429 for rate limit exceeded) and error messages in the JSON response. Your application should be able to gracefully handle these situations, as detailed in the Telize API documentation on error codes.
2. Dynamic IP Address Lookup: Instead of hardcoding an IP address, integrate logic to dynamically retrieve the IP address you want to geolocate. This could be a user's connecting IP address, an IP address from a log, or one provided through another service.
3. Rate Limit Management: Be aware of your current plan's request limits (e.g., 1,000 requests/day for the free tier). Implement a caching strategy or request queuing to manage your API calls efficiently and avoid hitting rate limits.
4. Explore Additional Features: Review the Telize API reference for any advanced features or additional endpoints that might be relevant to your use case.
5. Security Best Practices: Ensure your API key is stored securely and not exposed in client-side code if the requests are made directly from a browser. For browser-based applications, consider using a backend proxy to make Telize API calls, protecting your key. Best practices for API key security generally apply to Telize as well.
6. Billing and Upgrading: If your usage exceeds the free tier, consider upgrading to a paid plan. Monitor your usage through your Telize dashboard and review the Telize pricing page to choose a plan that fits your needs.
7. Integrate with SDKs: If you are working in a JavaScript environment, leverage the official Telize JavaScript SDK to simplify interactions with the API, abstracting away direct HTTP request handling.

Troubleshooting the first call

If your first Telize API request doesn't return the expected geolocation data, consider the following common issues and troubleshooting steps:

• Invalid API Key (HTTP 401 Unauthorized):

  • Issue: This is the most common error, indicating that the API key provided is either incorrect, expired, or missing.
  • Solution: Double-check your API key for typos. Ensure you have copied the entire key from your Telize dashboard. Log in to your Telize account to verify the key's validity and ensure it hasn't been revoked or is not pending activation.

• Rate Limit Exceeded (HTTP 429 Too Many Requests):

  • Issue: Even during initial testing, if you make too many requests in a short period, you might hit the free tier's rate limit (1,000 requests/day).
  • Solution: Wait for some time (e.g., an hour or the next day) for the rate limit to reset. Check your Telize dashboard for real-time usage statistics. If you need higher limits, consider upgrading your plan on the Telize pricing page.

• Incorrect Endpoint or IP Address Format (HTTP 400 Bad Request):

  • Issue: The API may return a 400 if the URL structure is incorrect or the IP address provided is malformed.
  • Solution: Verify that the base URL is https://api.telize.com/geoip/ and that the IP address is correctly appended. Ensure the IP address is a valid IPv4 or IPv6 format. Consult the Telize API documentation for the exact endpoint structure.

• Network Connectivity Issues:

  • Issue: Your development environment or network might be blocking outbound HTTP requests, or there might be an issue with DNS resolution.
  • Solution: Test connectivity to other external services. If using cURL, try a simple request like curl google.com. Check firewall settings or proxy configurations that might interfere with HTTP requests.

• Empty or Unexpected JSON Response:

  • Issue: The request succeeds, but the JSON response is empty, malformed, or missing expected data.
  • Solution: Ensure your code properly parses the JSON response. Some libraries might require specific headers (e.g., Accept: application/json) though Telize typically defaults to JSON. If querying a private IP address (e.g., 192.168.1.1), Telize will not return public geolocation data; ensure you are querying a public, routable IP address.

• SSL/TLS Certificate Errors:

  • Issue: Less common, but older environments or misconfigured clients might encounter issues with SSL/TLS certificates when connecting to https://api.telize.com.
  • Solution: Ensure your system's root certificates are up to date. Most modern HTTP clients handle this automatically.

When troubleshooting, always begin by checking the HTTP status code returned by the API, as it provides the primary indicator of the problem's nature.