BigDataCloud Getting Started: API Keys, Endpoints (2026)

Getting started overview

Getting started with BigDataCloud involves a straightforward process of account creation, API key retrieval, and making your first authenticated request. BigDataCloud provides various APIs, including Reverse Geocoding, IP Geolocation, Client Info, and Network Info, designed for developers needing location-based and network-related data (BigDataCloud API documentation). The platform offers a free tier, allowing up to 50,000 requests per day, making it accessible for initial development and testing without immediate financial commitment (BigDataCloud pricing details).

The developer experience is designed for quick integration, offering clear documentation and code examples in several popular programming languages, such as JavaScript, Python, PHP, and cURL. This guide will walk you through the essential steps to get your first BigDataCloud API call working.

Quick Reference Table

Create an account and get keys

To access any BigDataCloud API, you first need a developer account. This account grants you access to the developer portal, where you can manage your API keys, monitor usage, and access documentation.

1. Navigate to the Signup Page: Go to the official BigDataCloud Developer Portal signup page.
2. Complete Registration: Fill out the required fields, which typically include your name, email address, and a password. You may need to agree to terms of service and privacy policies. After submission, you might receive an email to verify your account. Follow the instructions in the email to complete the verification process.
3. Access the Dashboard: Once your account is created and verified, log in to the BigDataCloud Developer Portal dashboard.
4. Retrieve Your API Key: Your unique API key will be prominently displayed on your dashboard. This key is essential for authenticating all your API requests. Treat your API key as sensitive information; do not hardcode it directly into client-side code or expose it publicly. For server-side applications, it's recommended to store it as an environment variable or in a secure configuration file. For client-side use, BigDataCloud's APIs often allow for direct client-side calls, but consider rate limits and potential abuse (BigDataCloud security best practices).

Your first request

With your API key in hand, you can now make your first API call. We'll use the Reverse Geocoding API as an example, which converts geographic coordinates (latitude and longitude) into a human-readable address. This is a common pattern for location-based services (Google Maps Geocoding API overview).

Reverse Geocoding API Example

The Reverse Geocoding API endpoint requires latitude and longitude parameters. The base URL for this API is https://api.bigdatacloud.net/data/reverse-geocode-client.

API Parameters:

• latitude: The latitude coordinate.
• longitude: The longitude coordinate.
• key: Your BigDataCloud API key.

Example using cURL (Command Line)

Replace YOUR_API_KEY with your actual API key and adjust the latitude and longitude values as needed.

curl "https://api.bigdatacloud.net/data/reverse-geocode-client?latitude=34.052235&longitude=-118.243683&key=YOUR_API_KEY"

This cURL command requests reverse geocoding for the coordinates of downtown Los Angeles.

Example using JavaScript (Fetch API)

For web applications, you can use the Fetch API. Remember to handle your API key securely, especially in client-side applications. For production, consider proxying requests through your own backend to hide the key.

const latitude = 34.052235;
const longitude = -118.243683;
const apiKey = 'YOUR_API_KEY'; // Replace with your actual API key

const url = `https://api.bigdatacloud.net/data/reverse-geocode-client?latitude=${latitude}&longitude=${longitude}&key=${apiKey}`;

fetch(url)
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
  })
  .then(data => {
    console.log('Reverse Geocoding Data:', data);
    // Process the data, e.g., display the address
    if (data && data.locality) {
      console.log(`Location: ${data.locality}, ${data.countryName}`);
    }
  })
  .catch(error => {
    console.error('Error fetching reverse geocoding data:', error);
  });

Example using Python (Requests Library)

Python's requests library is a common choice for making HTTP requests.

import requests

latitude = 34.052235
longitude = -118.243683
api_key = 'YOUR_API_KEY'  # Replace with your actual API key

url = f"https://api.bigdatacloud.net/data/reverse-geocode-client?latitude={latitude}&longitude={longitude}&key={api_key}"

try:
    response = requests.get(url)
    response.raise_for_status()  # Raise an exception for HTTP errors (4xx or 5xx)
    data = response.json()
    print("Reverse Geocoding Data:", data)
    if data and 'locality' in data:
        print(f"Location: {data['locality']}, {data['countryName']}")
except requests.exceptions.RequestException as e:
    print(f"Error fetching reverse geocoding data: {e}")

Interpreting the Response

A successful response from the Reverse Geocoding API will return a JSON object containing various address components, such as countryName, locality, principalSubdivision, and postcode. You can parse this JSON to extract the specific information you need for your application.

Common next steps

After successfully making your first API call, consider these next steps to further integrate BigDataCloud into your projects:

1. Explore Other APIs: BigDataCloud offers several other APIs, including the IP Geolocation API (to get location data from an IP address) and the Client Info API (to retrieve details about the client's network and device). Consult the BigDataCloud API reference to understand their capabilities and integrate them as needed.
2. Monitor Usage: Regularly check your usage statistics on the BigDataCloud Developer Portal dashboard. This helps you stay within your free tier limits or monitor usage against your paid plan, preventing unexpected service interruptions.
3. Implement Rate Limiting and Error Handling: As with any external API, implement robust error handling in your application to gracefully manage network issues, invalid requests, or API rate limits. BigDataCloud's APIs are subject to rate limits, and exceeding them will result in 429 Too Many Requests errors. Proper error handling ensures a better user experience (BigDataCloud rate limit documentation).
4. Secure Your API Key: Review and implement best practices for API key security. Avoid embedding keys directly in public client-side code. For server-side applications, use environment variables or a secrets management service. For sensitive client-side use cases, consider a backend proxy to protect your key.
5. Upgrade Your Plan (If Needed): If your application's usage exceeds the free tier (50,000 requests/day), consider upgrading to a paid plan. BigDataCloud offers various tiers starting from the Pro Plan at $20/month for 100,000 requests/day, scaling up with higher request volumes (BigDataCloud pricing page).
6. Review SDKs and Libraries: While BigDataCloud does not currently provide official SDKs, community-contributed libraries or wrappers might exist. For general API client development, tools like Postman's API Client can be useful for testing and prototyping requests.

Troubleshooting the first call

If your first BigDataCloud API call doesn't work as expected, consider these common troubleshooting steps:

1. Check Your API Key: Ensure your API key is correct and hasn't been mistyped. API keys are case-sensitive. Verify it against the key displayed on your BigDataCloud Developer Portal dashboard.
2. Verify Endpoint URL: Double-check the API endpoint URL for any typos. Ensure it matches the official documentation for the specific API you are trying to use (e.g., https://api.bigdatacloud.net/data/reverse-geocode-client).
3. Inspect Parameters: Confirm that all required parameters (like latitude and longitude for reverse geocoding) are included and correctly formatted. Latitude ranges from -90 to +90, and longitude from -180 to +180.
4. Review HTTP Status Codes:
   • 200 OK: The request was successful. Check the response body for data.
   • 400 Bad Request: Often indicates missing or malformed parameters. Review your URL and query string.
   • 401 Unauthorized: Your API key is likely missing or invalid.
   • 403 Forbidden: Your API key might not have permission for the requested resource, or there's an issue with your account.
   • 429 Too Many Requests: You have exceeded your daily or per-minute request limit. Check your dashboard for usage.
   • 5xx Server Error: An issue on BigDataCloud's end. These are less common but can occur.
5. Check Network Connectivity: Ensure your development environment has an active internet connection and no firewall rules are blocking outgoing requests to api.bigdatacloud.net.
6. Consult Documentation: Refer to the specific BigDataCloud API documentation for the endpoint you are using. It provides detailed information on required parameters, expected responses, and potential error codes.
7. Browser Developer Tools: When testing in a browser or web application, use the browser's developer tools (Network tab) to inspect the outgoing request and the incoming response. This can reveal status codes, headers, and response bodies that aid in debugging.