ipify Getting Started: Retrieve IP Addresses (2026)

Getting started overview

Integrating with ipify primarily involves obtaining an API key and constructing simple HTTP GET requests. The ipify API provides endpoints for retrieving a client's public IPv4 or IPv6 address, and for paid plans, associated geolocation data. This guide outlines the essential steps to make your first successful call.

The core process includes:

1. Account Creation: Registering on the ipify website to generate an API key.
2. API Key Retrieval: Locating your unique API key in your account dashboard.
3. First Request: Sending an HTTP GET request to the ipify API endpoint, including your API key for authentication.
4. Response Handling: Parsing the plain text or JSON response to extract the IP address or geolocation details.

The following table summarizes the key steps:

Create an account and get keys

To access ipify's services beyond basic IP address lookup (which does not require a key), an API key is necessary for features such as geolocation and increased rate limits. The free tier includes 10,000 requests per month and requires an API key for tracking usage and enabling specific features.

Follow these steps to create an account and retrieve your API key:

1. Navigate to ipify: Go to the ipify official website.
2. Sign Up: Click on the 'Sign Up' or 'Get Started' button. You will be prompted to create an account using your email address and a password.
3. Confirm Email: After submitting your registration, check your email inbox for a verification link. Click this link to activate your account.
4. Access Dashboard: Log in to your newly created account. You will be directed to your user dashboard.
5. Locate API Key: Your unique API key is typically displayed prominently on the dashboard. It is a long string of alphanumeric characters. Copy this key, as it will be required for all authenticated API requests. Keep your API key secure and do not expose it in client-side code or public repositories.

Your first request

Once you have your API key, you can make your first request to the ipify API. The primary endpoint for retrieving an IP address without an API key is https://api.ipify.org. For features requiring an API key (e.g., geolocation), or for tracking usage on the free tier, you'll use a slightly different endpoint structure.

This example demonstrates how to retrieve your public IP address using the basic endpoint, which does not require an API key unless you specifically need to log usage against your account or access advanced features like geolocation. For advanced features or explicit API key usage, refer to the ipify API Documentation.

Using cURL (without API key)

To fetch your IPv4 address as plain text:

curl https://api.ipify.org

To fetch your IPv6 address as plain text:

curl https://api6.ipify.org

To fetch your IP address in JSON format (including ip and proxy status fields):

curl https://api.ipify.org?format=json

Example Response (JSON):

{
  "ip": "192.0.2.1",
  "proxy": false
}

Using Python (without API key)

Install the requests library if you haven't already: pip install requests.

import requests

try:
    response = requests.get("https://api.ipify.org?format=json")
    response.raise_for_status() # Raise an exception for HTTP errors
    data = response.json()
    print(f"Your IP address: {data['ip']}")
except requests.exceptions.RequestException as e:
    print(f"Error fetching IP: {e}")

Using JavaScript (Browser, without API key)

fetch('https://api.ipify.org?format=json')
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
  })
  .then(data => {
    document.getElementById('ip-address').textContent = `Your IP address: ${data.ip}`;
  })
  .catch(error => {
    console.error('Error fetching IP:', error);
    document.getElementById('ip-address').textContent = 'Failed to retrieve IP address.';
  });

// Assuming you have an HTML element with id="ip-address" to display the result

For calls requiring your API key (e.g., for geolocation or tracking usage), the endpoint structure would typically include your key as a query parameter:

curl "https://api.ipify.org?format=json&apiKey=YOUR_API_KEY"

Replace YOUR_API_KEY with the key obtained from your ipify dashboard.

Common next steps

After successfully retrieving your IP address, several common next steps can enhance your integration with ipify or expand its utility:

• Explore Geolocation: If your plan includes geolocation, you can modify your requests to include parameters that return location data associated with the IP address. This typically involves an additional endpoint or query parameters with your API key, as detailed in the ipify API documentation.
• Implement Error Handling: Incorporate robust error handling in your application to manage network issues, invalid API keys, or API rate limit responses. The API will return standard HTTP status codes for errors, such as 401 Unauthorized for invalid keys or 429 Too Many Requests for exceeding rate limits. Understanding HTTP response status codes is crucial for this.
• Monitor Usage: Regularly check your ipify dashboard to monitor your API request volume. This helps ensure you stay within your plan's limits and anticipate when an upgrade might be necessary.
• Secure API Keys: If your application is deployed on a server, use environment variables or a secrets management service to store your API key instead of hardcoding it. For client-side applications, consider proxying requests through your own backend to prevent direct exposure of the API key to end-users.
• Rate Limiting Strategies: If your application makes frequent requests, implement client-side rate limiting or caching mechanisms to optimize usage and avoid hitting ipify's API rate limits.
• Review Pricing: As your usage grows, review the ipify pricing page to understand available tiers and select a plan that aligns with your application's needs.
• Integrate with Other Services: Combine ipify's IP lookup capabilities with other services, such as a Cloudflare API for DNS management or an AWS EC2 API for instance management, to build more complex network monitoring or security solutions.

Troubleshooting the first call

Encountering issues during your first API call is common. Here's a guide to help diagnose and resolve potential problems:

• Invalid API Key (401 Unauthorized):
  • Issue: You receive an HTTP 401 error or a message indicating an unauthorized request.
  • Solution: Double-check that you have copied the API key correctly from your ipify dashboard. Ensure there are no leading or trailing spaces. Verify that you are including the apiKey query parameter if your specific endpoint or feature requires it.
• Missing API Key Parameter:
  • Issue: Your request fails, and the documentation states an API key is required, but you haven't included it.
  • Solution: Add &apiKey=YOUR_API_KEY to your request URL, replacing YOUR_API_KEY with your actual key.
• Rate Limit Exceeded (429 Too Many Requests):
  • Issue: You receive an HTTP 429 error.
  • Solution: This indicates you've sent too many requests within a short period or exceeded your monthly quota. Wait for a few moments and try again, or check your dashboard for usage statistics. Consider implementing client-side rate limiting or upgrading your plan if this occurs frequently.
• Network Connectivity Issues:
  • Issue: Your request times out or reports a network error.
  • Solution: Verify your internet connection. Ensure there are no firewalls or proxy settings blocking outgoing HTTP requests from your environment to api.ipify.org. Try making a request to another known public API (e.g., https://api.github.com) to test general connectivity.
• Incorrect Endpoint URL:
  • Issue: You receive a 404 Not Found error or an unexpected response.
  • Solution: Confirm that the URL you are calling matches the official ipify API documentation. Pay attention to http vs. https and the correct domain (api.ipify.org or api6.ipify.org).
• Invalid JSON Parsing:
  • Issue: Your code fails when trying to parse the API response as JSON.
  • Solution: Ensure you are sending the format=json query parameter if you expect a JSON response. If you don't specify a format, ipify defaults to plain text. Before parsing, inspect the raw response content to confirm its structure.