Intelligence X Authentication: API Key Setup & Security (2026)

Authentication overview

Intelligence X provides programmatic access to its extensive collection of Open Source Intelligence (OSINT) data, including data breaches and darknet monitoring results. To interact with the Intelligence X API, clients must authenticate their requests. The primary method for authentication is through an API key, which acts as a unique identifier and secret for your account.

API keys are generated through the Intelligence X user interface, typically within an account's security or API settings section. Once obtained, this key must be included with every API request to authorize access to the data and services. The Intelligence X API supports various programming languages through official SDKs, simplifying the integration of authentication into applications developed in Python, Go, PHP, JavaScript, PowerShell, and C#.

Proper management and secure handling of API keys are critical to maintaining the security of your Intelligence X account and preventing unauthorized access to sensitive OSINT data. This includes practices such as storing keys securely, transmitting them over encrypted channels, and implementing robust key rotation policies.

Supported authentication methods

Intelligence X utilizes a straightforward authentication model focused on API keys. This method is common for external API access due to its simplicity and effectiveness when implemented with appropriate security measures.

The API key functions as a bearer token, meaning it confers authorization to the holder. When an API key is compromised, it can grant unauthorized access to the associated account's data and capabilities. Therefore, understanding and mitigating the risks associated with API key usage is paramount. Organizations like Cloudflare and Google also emphasize secure API key management for their services, highlighting industry-wide best practices.

Getting your credentials

To obtain an API key for Intelligence X, follow these steps:

1. Account Creation/Login: First, ensure you have an active Intelligence X account. If you do not, you will need to register for one. API access typically requires a paid subscription, starting with the Personal tier at 29.99 EUR/month.
2. Navigate to API Settings: Log in to your Intelligence X account through the web interface. Look for a section related to 'API Keys', 'Account Settings', or 'Security' in your dashboard. The exact navigation may vary but is usually intuitive. Refer to the official Intelligence X documentation for precise instructions.
3. Generate New API Key: Within the API settings, there should be an option to generate a new API key. This process typically involves clicking a button like 'Generate New Key' or 'Create API Key'.
4. Copy and Store Your Key: Once generated, your API key will be displayed. It is crucial to copy this key immediately and store it securely. For security reasons, API keys are often only shown once upon generation and cannot be retrieved later. If lost, you will need to generate a new key.
5. Manage Existing Keys: The API settings page also allows you to manage your existing API keys, including options to revoke or regenerate them. Regularly reviewing and revoking unused or compromised keys is a recommended security practice.

Intelligence X provides clear guidance on API key management within its user interface and API reference documentation. Adhering to these instructions ensures that your integration is set up correctly and securely.

Authenticated request example

Once you have obtained your API key, you can use it to authenticate your requests to the Intelligence X API. The API key is typically sent in the x-apikey HTTP header for most endpoints.

Python example using the official SDK

The Intelligence X Python SDK simplifies authentication by allowing you to initialize the client with your API key.

import intelx

# Replace 'YOUR_API_KEY' with your actual Intelligence X API key
intelx_api_key = "YOUR_API_KEY"

# Initialize the Intelligence X client with your API key
intelx_client = intelx.intelx(intelx_api_key)

try:
    # Example: Search for a specific term
    search_term = "example.com"
    print(f"Searching for: {search_term}")
    search_id = intelx_client.search(search_term, "past24h", maxresults=10, timeout=10)

    # Wait for the search to complete and get results
    # Note: In a real application, you might poll for results asynchronously
    search_result = intelx_client.waitforsearch(search_id, 30)

    if search_result and search_result['status'] == 0:
        print("Search results:")
        for item in search_result['records']:
            print(f"  - {item['name']}: {item['value']}")
    else:
        print(f"Search failed or no results: {search_result}")

except Exception as e:
    print(f"An error occurred: {e}")

Raw HTTP request example (using curl)

For direct API calls without an SDK, you would include the API key in the x-api-key header:

curl -X GET \
  'https://public.api.intelx.io/GET/VERSION' \
  -H 'x-api-key: YOUR_API_KEY'

This example demonstrates how to perform a simple authenticated request to retrieve the API version. Remember to replace 'YOUR_API_KEY' with your actual Intelligence X API key. Consult the Intelligence X API documentation for specific endpoint details and request parameters.

Security best practices

Adhering to security best practices for API key management is essential to protect your Intelligence X account and the sensitive data it provides. Improper handling of API keys can lead to unauthorized access, data breaches, and service abuse.

• Secure Storage: Never hardcode API keys directly into your application's source code. Instead, store them in environment variables, configuration files that are excluded from version control (e.g., using .env files and .gitignore), or secure secret management services (e.g., HashiCorp Vault, AWS Secrets Manager, Google Cloud Secret Manager). This prevents keys from being exposed in public repositories.
• Least Privilege: If Intelligence X offers granular API key permissions in the future (though not currently specified), generate keys with only the necessary permissions required for the task. This minimizes the impact if a key is compromised.
• HTTPS Usage: Always ensure that all API requests are made over HTTPS (HTTP Secure). This encrypts the communication channel between your application and the Intelligence X API, protecting your API key from interception during transmission. The Intelligence X API inherently uses HTTPS, so always use https:// in your API endpoint URLs.
• Key Rotation: Regularly rotate your API keys. This means generating a new key and replacing the old one. Frequent rotation limits the window of exposure if a key is compromised without your knowledge. Establish a schedule for key rotation based on your organization's security policies.
• Monitoring and Alerting: Implement monitoring for API key usage. Look for unusual patterns, such as an exceptionally high number of requests, requests from unexpected geographical locations, or requests for unauthorized resources. Set up alerts to notify you of suspicious activity immediately.
• Revocation: If you suspect an API key has been compromised or is no longer needed, revoke it immediately through your Intelligence X account's API settings. This invalidates the key, preventing any further unauthorized use.
• Client-Side Security: Avoid exposing API keys in client-side code (e.g., JavaScript in a web browser) where they can be easily accessed by end-users. If client-side interaction is required, route requests through a secure backend server that adds the API key before forwarding to Intelligence X.
• Access Control: Restrict access to individuals or systems that require the API key. Implement strong access controls and authentication for anyone authorized to manage or use API keys within your organization.

By diligently applying these security measures, you can significantly reduce the risk of API key compromise and maintain the integrity and confidentiality of your interactions with Intelligence X. Refer to the Intelligence X official documentation for any platform-specific security recommendations.