GET /intel

Domain Intel

Learn more: Domain Intelligence API — marketing overview, live demo, and use cases.

Get comprehensive domain intelligence including availability status, parked domain detection, and a live screenshot.

Endpoint

GET https://api.robotdomainsearch.com/intel

Parameters

Parameter	Type	Required	Description
domain	string	Yes	Full domain name to analyze (e.g., example.com)

Request

curl "https://api.robotdomainsearch.com/intel?domain=example.com"

Response

Available Domain

When a domain is available for registration, parking detection is skipped:

{
  "domain": "mycoolstartup.com",
  "available": true,
  "parked": false
}

Registered Domain (with parked detection)

When a domain is registered, the intel service captures a screenshot and analyzes whether it’s parked:

{
  "domain": "example.com",
  "available": false,
  "parked": true,
  "parked_confidence": 0.92,
  "parked_signals": [
    "generic_content",
    "ad_heavy",
    "registrar_landing"
  ],
  "screenshot_url": "https://intel.robotdomainsearch.com/screenshots/example.com.png",
  "final_url": "https://www.example.com/",
  "load_time_ms": 1250
}

Active Website (not parked)

{
  "domain": "github.com",
  "available": false,
  "parked": false,
  "parked_confidence": 0.05,
  "parked_signals": [],
  "screenshot_url": "https://intel.robotdomainsearch.com/screenshots/github.com.png",
  "final_url": "https://github.com/",
  "load_time_ms": 890
}

Screenshot Service Unavailable

If the screenshot service is down, the endpoint degrades gracefully:

{
  "domain": "example.com",
  "available": false,
  "parked": false,
  "error": "screenshot_service_unavailable"
}

Response Fields

Field	Type	Description
domain	string	The domain that was analyzed
available	boolean	true if the domain is available for registration
parked	boolean	true if the domain appears to be parked
parked_confidence	number	Confidence score for parked detection (0.0–1.0, omitted if not analyzed)
parked_signals	array	Signals that indicate the domain is parked (omitted if not analyzed)
screenshot_url	string	URL to the captured screenshot (omitted if unavailable)
final_url	string	Final URL after redirects (omitted if unavailable)
load_time_ms	integer	Page load time in milliseconds (omitted if unavailable)
error	string	Error message if screenshot capture failed (omitted on success)

Errors

Code	Error	Description
400	missing_parameter	The domain parameter is required
400	invalid_domain	Domain must include a TLD (e.g., example.com)
405	method_not_allowed	Only GET method is allowed
503	service_unavailable	Intel service not configured

Code Examples

curl

curl "https://api.robotdomainsearch.com/intel?domain=example.com"

Python

import requests

response = requests.get(
    "https://api.robotdomainsearch.com/intel",
    params={"domain": "example.com"}
)
data = response.json()

print(f"Domain: {data['domain']}")
print(f"Available: {data['available']}")
print(f"Parked: {data['parked']}")

if data.get("parked_confidence"):
    print(f"Confidence: {data['parked_confidence']:.0%}")

if data.get("parked_signals"):
    print(f"Signals: {', '.join(data['parked_signals'])}")

if data.get("screenshot_url"):
    print(f"Screenshot: {data['screenshot_url']}")

if data.get("error"):
    print(f"Warning: {data['error']}")

JavaScript

const response = await fetch(
  "https://api.robotdomainsearch.com/intel?domain=example.com"
);
const data = await response.json();

console.log(`Domain: ${data.domain}`);
console.log(`Available: ${data.available}`);
console.log(`Parked: ${data.parked}`);

if (data.parked_confidence) {
  console.log(`Confidence: ${(data.parked_confidence * 100).toFixed(0)}%`);
}

if (data.parked_signals?.length) {
  console.log(`Signals: ${data.parked_signals.join(", ")}`);
}

if (data.screenshot_url) {
  console.log(`Screenshot: ${data.screenshot_url}`);
}

Go

resp, err := http.Get("https://api.robotdomainsearch.com/intel?domain=example.com")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

var data struct {
    Domain           string   `json:"domain"`
    Available        bool     `json:"available"`
    Parked           bool     `json:"parked"`
    ParkedConfidence float64  `json:"parked_confidence,omitempty"`
    ParkedSignals    []string `json:"parked_signals,omitempty"`
    ScreenshotURL    string   `json:"screenshot_url,omitempty"`
    FinalURL         string   `json:"final_url,omitempty"`
    LoadTimeMs       int64    `json:"load_time_ms,omitempty"`
    Error            string   `json:"error,omitempty"`
}

if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    log.Fatal(err)
}

fmt.Printf("Domain: %s (available: %t, parked: %t)\n", data.Domain, data.Available, data.Parked)
if data.ParkedConfidence > 0 {
    fmt.Printf("Parked confidence: %.0f%%\n", data.ParkedConfidence*100)
}
if data.ScreenshotURL != "" {
    fmt.Printf("Screenshot: %s\n", data.ScreenshotURL)
}

Notes

• Domain names are automatically normalized to lowercase and protocol prefixes are stripped
• Availability is checked via RDAP before attempting screenshot capture
• If a domain is available, parked detection is skipped entirely (no screenshot taken)
• The screenshot service may be temporarily unavailable — the endpoint returns partial data rather than failing
• Parked detection uses signals like generic content, heavy advertising, and registrar landing pages
• The final_url field shows where the domain redirects to, useful for detecting redirect chains

📄 Raw markdown: /docs/api/intel.md