Name: IP & Domain Intelligence API: Real-time WHOIS, DNS, Risk Loo
Brand: quickpod
SKU: api-quickpod-aiquick-ip
Availability: InStock
Author: API Market

Anil Singh

# IP & Domain Intelligence API

## Overview
The IP & Domain Intelligence API provides real-time, comprehensive data on IP addresses and domains by querying live IANA/RIR registries. This powerful API offers immediate access to critical network and domain information, including IP ASN details, network CIDR, domain WHOIS records, domain age, and various DNS record types. It's designed for developers and systems that require accurate, registry-sourced intelligence for a wide range of applications from cybersecurity to network management and fraud detection.

The API delivers compact, reliable results, making it ideal for integration into existing workflows for traffic analysis, asset inventory, threat intelligence, and security incident response. By leveraging official registry data, it provides more precise and trustworthy information than services relying on inferred or guessed data.

## Features
*   **IP ASN Lookup:** Resolve IP addresses to their Autonomous System Number (ASN), network name, CIDR block, registry, country code, and description directly from RDAP.
*   **IP Risk Scoring:** Assess the heuristic risk level of an IP address based on its ASN type (e.g., datacenter) and associated country.
*   **Domain WHOIS Lookup:** Retrieve complete WHOIS records for domains, including registrar information, creation and expiry dates, name servers, and contact details.
*   **Domain Age Calculation:** Determine the precise age of a domain in days and years using its WHOIS creation date.
*   **DNS Record Resolution:** Perform lookups for various DNS record types (A, AAAA, MX, TXT, NS, CNAME, SOA, PTR, CAA) for any given domain.
*   **Real-time Data:** All lookups leverage live IANA/RIR registries for the most current and accurate information.
*   **Compact Responses:** Optimized for easy integration into high-volume data processing and analytics pipelines.

## Use Cases
1.  **Cybersecurity & Threat Intelligence:** Enhance Security Information and Event Management (SIEM) systems by enriching logs with IP and domain ownership, network details, and risk scores. Identify suspicious IP addresses associated with known bad ASNs or risky countries, aiding in **incident response triage** and **threat hunting**.
2.  **Fraud Detection & Prevention:** Integrate IP and domain intelligence into fraud detection systems to verify transaction origins, identify proxy or VPN usage, and check the age and reputation of domains used in phishing or scam attempts. This helps in **real-time risk assessment** for financial services and e-commerce.
3.  **Network Operations & Asset Inventory:** Automate the mapping of internal and external IP addresses to their respective ASN, network, and geographical details. This facilitates **network topology mapping**, **asset inventory management**, and understanding traffic flows, crucial for IT infrastructure teams.
4.  **Website & Application Security:** Implement pre-emptive security checks for incoming user requests by analyzing their IP address for risk factors or domain WHOIS data for suspicious registrations. Use domain age to filter out newly registered domains often associated with **spam and phishing campaigns**.
5.  **Compliance & Regulatory Reporting:** Verify the geographical origin of traffic or data associated with specific ASNs for regulatory compliance. Use WHOIS data for **due diligence** on third-party domains or to ensure legitimate domain registrations.

## API Documentation

### Base URL
All API requests should be made to: `https://prod.api.market/api/v1/quickpod/aiquick-ip`

### Authentication
Authentication is handled via API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```


### Endpoints

#### 1. Service health check
Check the service's operational status.

```
GET /api/v1/quickpod/aiquick-ip/health
```

**Parameters:**
*   **Header:** `x-api-market-key` (required) - Your API.market API Key.

**Example Request (cURL):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/health" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK):**
```json
{
  "ok": true,
  "service": "IP & Domain Intelligence API"
}
```

#### 2. Look up ASN, network CIDR, and registry details for an IP via RDAP
Resolves an IP address to its associated network and registry details, including ASN, network name, CIDR, and country, using live RDAP data.

```
GET /api/v1/quickpod/aiquick-ip/v1/ip/asn
```

**Parameters:**
*   **Query:** `ip` (required, string) - The IP address to look up. Example: `8.8.8.8`
*   **Header:** `x-api-market-key` (required) - Your API.market API Key.

**Example Request (cURL):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/ip/asn?ip=8.8.8.8" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK):**
```json
{
  "ip": "8.8.8.8",
  "asn": "15169",
  "asn_description": "GOOGLE",
  "asn_country_code": "US",
  "asn_registry": "arin",
  "network_name": "GOOGLE",
  "network_cidr": "8.8.8.0/24"
}
```

**Error Response (502 RDAP lookup failed):**
```json
{
  "detail": "RDAP lookup failed for 99.99.99.99"
}
```

#### 3. Heuristic risk score for an IP based on ASN type and country
Provides a heuristic risk score for an IP address based on its underlying ASN metadata, such as datacenter flag or sanctioned country.

```
GET /api/v1/quickpod/aiquick-ip/v1/ip/risk
```

**Parameters:**
*   **Query:** `ip` (required, string) - The IP address to score. Example: `1.2.3.4`
*   **Header:** `x-api-market-key` (required) - Your API.market API Key.

**Example Request (cURL):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/ip/risk?ip=34.64.0.1" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK - Datacenter ASN):**
```json
{
  "ip": "34.64.0.1",
  "risk_score": 30,
  "risk_level": "medium",
  "flags": [
    "datacenter_asn"
  ],
  "asn_country_code": "US",
  "asn": "15169",
  "asn_description": "GOOGLE"
}
```

**Example Response (200 OK - Clean IP):**
```json
{
  "ip": "1.2.3.4",
  "risk_score": 0,
  "risk_level": "low",
  "flags": [],
  "asn_country_code": "AU",
  "asn": "38803",
  "asn_description": "WPL-AS-AP"
}
```

#### 4. Retrieve full WHOIS record for a domain
Retrieves the complete WHOIS record for a specified domain, including registrar, dates, name servers, and contact information.

```
GET /api/v1/quickpod/aiquick-ip/v1/domain/whois
```

**Parameters:**
*   **Query:** `domain` (required, string) - The domain name to look up. Example: `example.com`
*   **Header:** `x-api-market-key` (required) - Your API.market API Key.

**Example Request (cURL):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/domain/whois?domain=example.com" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK):**
```json
{
  "domain": "example.com",
  "registrar": "ICANN",
  "creation_date": "1995-08-14T00:00:00",
  "expiry_date": "2028-08-13T00:00:00",
  "name_servers": [
    "A.IANA-SERVERS.NET",
    "B.IANA-SERVERS.NET"
  ],
  "status": [],
  "emails": [],
  "country": null,
  "org": null
}
```

**Error Response (502 WHOIS lookup failed):**
```json
{
  "detail": "WHOIS lookup failed for nonexist.com"
}
```

#### 5. Calculate how old a domain is from its WHOIS creation date
Calculates the age of a domain in days and years based on its WHOIS creation date.

```
GET /api/v1/quickpod/aiquick-ip/v1/domain/age
```

**Parameters:**
*   **Query:** `domain` (required, string) - The domain name to calculate age for. Example: `google.com`
*   **Header:** `x-api-market-key` (required) - Your API.market API Key.

**Example Request (cURL):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/domain/age?domain=google.com" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK):**
```json
{
  "domain": "google.com",
  "creation_date": "1997-09-15T00:00:00+00:00",
  "age_days": 10537,
  "age_years": 28.8
}
```

**Error Response (502 WHOIS lookup failed):**
```json
{
  "detail": "WHOIS lookup failed for nonexist.com"
}
```

#### 6. Resolve any DNS record type for a domain name
Performs a DNS lookup for a specified domain and record type, returning the resolved records and their TTL.

```
GET /api/v1/quickpod/aiquick-ip/v1/dns/lookup
```

**Parameters:**
*   **Query:** `domain` (required, string) - The domain name for DNS resolution. Example: `google.com`
*   **Query:** `record_type` (optional, string, default: `A`) - The type of DNS record to resolve. Enum: `A`, `AAAA`, `MX`, `TXT`, `NS`, `CNAME`, `SOA`, `PTR`, `CAA`.
*   **Header:** `x-api-market-key` (required) - Your API.market API Key.

**Example Request (cURL - A record):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/dns/lookup?domain=google.com&record_type=A" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK - A record):**
```json
{
  "domain": "google.com",
  "record_type": "A",
  "records": [
    "142.250.80.46"
  ],
  "ttl": 300
}
```

**Example Request (cURL - MX record):**
```bash
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/dns/lookup?domain=gmail.com&record_type=MX" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response (200 OK - MX record):**
```json
{
  "domain": "gmail.com",
  "record_type": "MX",
  "records": [
    "5 gmail-smtp-in.l.google.com."
  ],
  "ttl": 3600
}
```

**Example Response (200 OK - NXDOMAIN):**
```json
{
  "domain": "notexist.invalid",
  "record_type": "A",
  "records": [],
  "error": "NXDOMAIN"
}
```

**Error Response (502 DNS resolution failed):**
```json
{
  "detail": "DNS resolution failed for nonexist.invalid"
}
```

## Status Codes
*   **200 OK:** The request was successful, and the response body contains the requested data.
*   **400 Bad Request:** The request was malformed or contained invalid input parameters. Check your request body or query parameters against the API documentation.
*   **401 Unauthorized:** Your API key is missing or invalid. Ensure you provide a valid `x-api-market-key` header.
*   **403 Forbidden:** Your API key is valid, but you do not have sufficient permissions to access the requested resource or perform the action.
*   **404 Not Found:** The requested resource could not be found. This might indicate an incorrect endpoint path.
*   **429 Too Many Requests:** You have exceeded your API rate limit. Implement a retry mechanism with exponential backoff.
*   **500 Internal Server Error:** An unexpected error occurred on the server. If this persists, please contact support.
*   **502 Bad Gateway:** The API encountered an issue communicating with an upstream service (e.g., RDAP or WHOIS registries). This can be transient; retrying might resolve it.
*   **503 Service Unavailable:** The service is temporarily unable to handle the request, often due to maintenance or overload. Retry after a short delay.

## Rate Limits
Specific rate limits are applied to prevent abuse and ensure fair usage. If you exceed your allocated rate limit, the API will return a `429 Too Many Requests` status code. We recommend implementing a retry mechanism with exponential backoff in your client application to gracefully handle rate limit errors. If you require higher rate limits, please contact us.

## Error Handling
When an error occurs, the API will return an appropriate HTTP status code along with a JSON response body containing an `error` or `detail` field that provides more information about the issue.

**How to Interpret Error Responses:**
*   **Check HTTP Status Code:** This is the primary indicator of the error type.
*   **Read `detail` or `error` Field:** The JSON response body will often contain a `detail` field for server-side errors or a structured `error` object for client-side validation failures.

**Common Errors and How to Resolve Them:**
*   **`400 Bad Request`:**
    *   **Cause:** Missing required query parameters (e.g., `ip`, `domain`), or invalid data types.
    *   **Resolution:** Verify your request against the endpoint's parameter definitions. Ensure all required fields are present and correctly formatted.
*   **`401 Unauthorized`:**
    *   **Cause:** Missing `x-api-market-key` header or an incorrect API key.
    *   **Resolution:** Double-check your API key and ensure it's included correctly in the `x-api-market-key` header for every request.
*   **`429 Too Many Requests`:**
    *   **Cause:** Exceeding the allowed number of requests within a given timeframe.
    *   **Resolution:** Implement client-side rate limiting or exponential backoff for retries. If persistent, consider upgrading your plan or contacting support for higher limits.
*   **`502 Bad Gateway`:**
    *   **Cause:** A temporary issue with an upstream service (e.g., IANA/RIR registry lookup failed).
    *   **Resolution:** This is often transient. Implement a retry strategy (e.g., 2-3 retries with a short delay) for these types of errors.

**Recommended Retry Strategies:**
For transient errors like `429 Too Many Requests`, `502 Bad Gateway`, and `503 Service Unavailable`, implement an exponential backoff strategy:
1.  Wait a short initial duration (e.g., 1 second).
2.  If the error persists, double the wait time for the next retry.
3.  Implement a maximum number of retries (e.g., 3-5 times) and a maximum total timeout.

**Error Response Example (Validation Error):**
```json
{
  "detail": "Missing required query parameter: ip"
}
```

## Implementation Guide

This API uses synchronous processing, meaning each request directly returns the final result. The examples below demonstrate how to make a request to the `/v1/ip/asn` endpoint, authenticate with your API key, and handle the synchronous response.

### Example Code

```javascript
// JavaScript example for synchronous API call
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/quickpod/aiquick-ip";

async function lookupIpAsn(ipAddress) {
  try {
    const response = await fetch(`${baseUrl}/v1/ip/asn?ip=${ipAddress}`, {
      method: "GET",
      headers: {
        "x-api-market-key": apiKey,
        "Content-Type": "application/json"
      }
    });

    if (response.status === 200) {
      const data = await response.json();
      console.log("IP ASN Lookup Result:", data);
      return data;
    } else {
      const errorData = await response.json();
      throw new Error(`API error ${response.status}: ${errorData.detail || JSON.stringify(errorData)}`);
    }
  } catch (error) {
    console.error("Error during IP ASN lookup:", error);
    throw error;
  }
}

// Example usage:
lookupIpAsn("8.8.8.8");
// For an IP that might fail (e.g., private range or non-routable):
// lookupIpAsn("192.168.1.1");
```

```python
# Python example for synchronous API call
import requests
import json

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/quickpod/aiquick-ip"

def lookup_ip_asn(ip_address):
    headers = {
        "x-api-market-key": API_KEY,
        "Content-Type": "application/json"
    }

    try:
        response = requests.get(
            f"{BASE_URL}/v1/ip/asn?ip={ip_address}",
            headers=headers,
            timeout=30 # Set a timeout for the request
        )
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)

        data = response.json()
        print("IP ASN Lookup Result:", json.dumps(data, indent=2))
        return data

    except requests.exceptions.HTTPError as e:
        print(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
        raise
    except requests.exceptions.ConnectionError as e:
        print(f"Connection error occurred: {e}")
        raise
    except requests.exceptions.Timeout as e:
        print(f"Request timed out: {e}")
        raise
    except requests.exceptions.RequestException as e:
        print(f"An unexpected error occurred: {e}")
        raise

# Example usage:
lookup_ip_asn("8.8.8.8")
# For an IP that might fail (e.g., private range or non-routable):
# lookup_ip_asn("192.168.1.1")
```

```bash
# cURL example for a synchronous API call
# Example: Look up ASN for 8.8.8.8
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/ip/asn?ip=8.8.8.8" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Example: Look up WHOIS for example.com
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/domain/whois?domain=example.com" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Example: Look up MX records for gmail.com
curl -X GET "https://prod.api.market/api/v1/quickpod/aiquick-ip/v1/dns/lookup?domain=gmail.com&record_type=MX" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
*   **Cache Results:** 
For static or infrequently changing data (like historical domain age), implement a caching layer in your application to reduce redundant API calls.
*   **Batch Requests (if applicable):** This API currently processes requests individually. If your workflow requires processing many items, consider parallelizing your requests within your rate limits.
*   **Efficient Querying:** Only request the specific data you need. While most endpoints are atomic, avoiding unnecessary calls contributes to overall efficiency.
*   **Error Handling and Retries:** Gracefully handle `429` and `5xx` errors with exponential backoff to ensure your application can recover from transient issues without overloading the API.

## FAQ

### What is an ASN?

An Autonomous System Number (ASN) is a unique identifier assigned to an Autonomous System (AS), which is a collection of IP networks and routing policies managed by a single organization, such as an ISP, university, or large enterprise. ASNs play a critical role in routing internet traffic.

### Why is registry data important for IP and Domain Intelligence?

Registry data from sources such as IANA, Regional Internet Registries (RIRs), and WHOIS registrars provides the authoritative record of IP address and domain ownership. Unlike services that infer information from IP databases, registry data reflects officially registered details, making it highly reliable for security, compliance, and network management.

### What happens if a field is `null` in the response?

If a registry does not publish a particular value (for example, an ASN description or certain WHOIS fields), the corresponding field in the API response will be `null`. Your application should handle these values gracefully and not assume that every field will always contain data.

### Is there a sandbox or testing environment?

Sandbox availability depends on your API.market subscription and account configuration. For testing, you can use well-known public IP addresses and domains to observe typical API responses.

### How do I get an API key?

API keys are issued when you subscribe to the IP & Domain Intelligence API on API.market. You can find your API key in your API.market dashboard after subscribing.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.

Access real-time IP network, domain WHOIS, and DNS resolution data directly from live registries. Enhance security, map traffic, and enrich network telemetry with authoritative IP intelligence.

IP & Domain Intelligence API: Real-time WHOIS, DNS, Risk Loo

Free