GET /v1/name-search-presence

Name Search Presence

Check how visible a name or brand is across major search engines. Returns a presence score (0–100), per-engine results, signal detection, and an AI-generated summary — useful for evaluating whether a name is already established online before registering a domain.

Endpoint

GET https://api.robotdomainsearch.com/v1/name-search-presence

Parameters

Parameter	Type	Required	Description
name	string	Yes	Name or brand to search for (e.g., mycoolstartup)
engines	string	No	Comma-separated list of engines to query. Options: brave, perplexity. Default: all engines.
timeout	int	No	Request timeout in milliseconds

Request

Basic — Check all engines

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=mycoolstartup"

Single engine

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=google&engines=brave"

Multiple engines with timeout

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=mycoolstartup&engines=brave,perplexity&timeout=5000"

Response

Clean name (low presence)

When a name has little or no online presence:

{
  "name": "mycoolstartup",
  "score": 7,
  "status": "clean",
  "summary": "No significant online presence exists for \"mycoolstartup\" as a brand, company, product, domain, social handle, or notable individual...",
  "engines": [
    {
      "engine": "perplexity",
      "score": 8,
      "exact_hits": 0,
      "loose_hits": 0,
      "total_results_estimate": 10,
      "top_matches": [
        {
          "title": "Marketing Tools & Branding Solutions | Canva",
          "url": "https://www.canva.com/solutions/startups/",
          "type": "brand",
          "relevance": "low"
        }
      ],
      "response_ms": 518
    },
    {
      "engine": "brave",
      "score": 5,
      "exact_hits": 0,
      "loose_hits": 0,
      "total_results_estimate": 0,
      "top_matches": [],
      "response_ms": 561
    }
  ],
  "signals": {
    "exact_phrase_found": false,
    "brand_exists": false,
    "company_exists": false,
    "product_exists": false,
    "domain_registered": false,
    "social_handles_found": [],
    "notable_individuals": []
  },
  "errors": [],
  "total_ms": 2642,
  "timestamp": "2026-02-17T14:00:20Z",
  "cache_hit": false
}

High presence name

When a name has strong existing presence:

{
  "name": "google",
  "score": 77,
  "status": "high",
  "summary": "**Google** is a major American multinational technology company renowned for its dominant search engine, extensive product portfolio, and key domains like google.com, about.google, and cloud.google.com...",
  "engines": [
    {
      "engine": "perplexity",
      "score": 78,
      "exact_hits": 10,
      "loose_hits": 10,
      "total_results_estimate": 10,
      "top_matches": [
        {
          "title": "Google - Wikipedia",
          "url": "https://en.wikipedia.org/wiki/Google",
          "type": "company",
          "relevance": "high"
        },
        {
          "title": "About Google: Our products, technology and company information",
          "url": "https://about.google",
          "type": "domain",
          "relevance": "high"
        }
      ],
      "response_ms": 730
    },
    {
      "engine": "brave",
      "score": 75,
      "exact_hits": 10,
      "loose_hits": 10,
      "total_results_estimate": 0,
      "top_matches": [
        {
          "title": "Google",
          "url": "https://www.google.com",
          "type": "domain",
          "relevance": "high"
        },
        {
          "title": "Google - Wikipedia",
          "url": "https://en.wikipedia.org/wiki/Google",
          "type": "company",
          "relevance": "high"
        }
      ],
      "response_ms": 769
    }
  ],
  "signals": {
    "exact_phrase_found": true,
    "brand_exists": false,
    "company_exists": true,
    "product_exists": true,
    "domain_registered": true,
    "social_handles_found": [],
    "notable_individuals": []
  },
  "errors": [],
  "total_ms": 2705,
  "timestamp": "2026-02-17T13:59:43Z",
  "cache_hit": false
}

Response Fields

Top-Level Fields

Field	Type	Description
name	string	The name that was searched
score	integer	Overall presence score (0–100)
status	string	Presence level: clean, low, medium, or high
summary	string	AI-generated summary of the name’s online presence
engines	array	Per-engine search results
signals	object	Detected presence signals
errors	array	Per-engine errors (partial failures)
total_ms	integer	Total response time in milliseconds
timestamp	ISO 8601	When the response was generated
cache_hit	boolean	Whether the response was served from cache

Scoring Guide

Score Range	Status	Meaning
0–10	clean	No meaningful online presence — name is likely available
11–30	low	Minimal presence — some loose matches but no strong brand
31–60	medium	Moderate presence — existing brands or products use this name
61–100	high	Strong presence — well-known brand, company, or individual

Engine Object

Field	Type	Description
engine	string	Search engine identifier (brave, perplexity)
score	integer	Per-engine presence score (0–100)
exact_hits	integer	Number of results with an exact name match
loose_hits	integer	Number of results with a partial/related match
total_results_estimate	integer	Estimated total results from this engine
top_matches	array	Top matching results from this engine
response_ms	integer	Engine response time in milliseconds

Top Match Object

Field	Type	Description
title	string	Page title of the result
url	string	URL of the result
type	string	Result type: domain, company, product, brand
relevance	string	Relevance level: high, medium, low

Signals Object

Field	Type	Description
exact_phrase_found	boolean	Whether the exact name appears in search results
brand_exists	boolean	Whether an existing brand uses this name
company_exists	boolean	Whether an existing company uses this name
product_exists	boolean	Whether an existing product uses this name
domain_registered	boolean	Whether a matching domain appears to be registered
social_handles_found	array	Social media handles found (if any)
notable_individuals	array	Notable individuals associated with this name (if any)

Error Handling

HTTP Status Codes

Status	Condition
200	Success (including partial failures with some engine data)
400	Missing or invalid name parameter
405	Method not allowed (only GET supported)
503	All engines failed / service unavailable

Partial Failures

If one engine fails, the other still returns data. Check the errors array:

{
  "name": "example",
  "score": 45,
  "status": "medium",
  "engines": [
    { "engine": "brave", "score": 45, "..." : "..." }
  ],
  "errors": [
    {
      "engine": "perplexity",
      "message": "request timeout"
    }
  ]
}

Use Cases

Brand name validation

Before registering a domain, check if the name is already taken by an established brand:

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=nextvault"

A clean or low status means the name is likely safe to use. A high status suggests potential trademark or branding conflicts.

Competitive analysis

Evaluate how established a competitor’s brand is online:

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=stripe"

Domain investment research

When evaluating domains to purchase, check if the name has existing brand value:

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=cloudpay"

A higher presence score may indicate the domain has more inherent value.

Code Examples

curl

curl "https://api.robotdomainsearch.com/v1/name-search-presence?name=mycoolstartup"

Python

import requests

response = requests.get(
    "https://api.robotdomainsearch.com/v1/name-search-presence",
    params={"name": "mycoolstartup"}
)
data = response.json()

print(f"Name: {data['name']}")
print(f"Score: {data['score']}/100 ({data['status']})")
print(f"Summary: {data['summary']}")

# Check signals
signals = data["signals"]
if signals["brand_exists"]:
    print("⚠️  Existing brand detected")
if signals["domain_registered"]:
    print("⚠️  Domain appears registered")
if signals["company_exists"]:
    print("⚠️  Existing company detected")

# Per-engine breakdown
for engine in data["engines"]:
    print(f"\n{engine['engine']}: {engine['score']}/100")
    print(f"  Exact hits: {engine['exact_hits']}")
    print(f"  Loose hits: {engine['loose_hits']}")
    for match in engine["top_matches"][:3]:
        print(f"  - {match['title']} ({match['relevance']})")

for error in data.get("errors", []):
    print(f"  Error [{error.get('engine')}]: {error.get('message')}")

JavaScript

const name = "mycoolstartup";
const response = await fetch(
  `https://api.robotdomainsearch.com/v1/name-search-presence?name=${name}`
);
const data = await response.json();

console.log(`Name: ${data.name}`);
console.log(`Score: ${data.score}/100 (${data.status})`);
console.log(`Summary: ${data.summary}`);

// Check signals
const { signals } = data;
if (signals.brand_exists) console.log("⚠️  Existing brand detected");
if (signals.domain_registered) console.log("⚠️  Domain appears registered");
if (signals.company_exists) console.log("⚠️  Existing company detected");

// Per-engine breakdown
data.engines.forEach(engine => {
  console.log(`\n${engine.engine}: ${engine.score}/100`);
  console.log(`  Exact hits: ${engine.exact_hits}`);
  engine.top_matches.slice(0, 3).forEach(match => {
    console.log(`  - ${match.title} (${match.relevance})`);
  });
});

data.errors?.forEach(e => {
  console.log(`  Error [${e.engine}]: ${e.message}`);
});

Go

resp, err := http.Get("https://api.robotdomainsearch.com/v1/name-search-presence?name=mycoolstartup")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()

var data struct {
    Name    string `json:"name"`
    Score   int    `json:"score"`
    Status  string `json:"status"`
    Summary string `json:"summary"`
    Engines []struct {
        Engine               string `json:"engine"`
        Score                int    `json:"score"`
        ExactHits            int    `json:"exact_hits"`
        LooseHits            int    `json:"loose_hits"`
        TotalResultsEstimate int    `json:"total_results_estimate"`
        TopMatches           []struct {
            Title     string `json:"title"`
            URL       string `json:"url"`
            Type      string `json:"type"`
            Relevance string `json:"relevance"`
        } `json:"top_matches"`
        ResponseMs int `json:"response_ms"`
    } `json:"engines"`
    Signals struct {
        ExactPhraseFound    bool     `json:"exact_phrase_found"`
        BrandExists         bool     `json:"brand_exists"`
        CompanyExists       bool     `json:"company_exists"`
        ProductExists       bool     `json:"product_exists"`
        DomainRegistered    bool     `json:"domain_registered"`
        SocialHandlesFound  []string `json:"social_handles_found"`
        NotableIndividuals  []string `json:"notable_individuals"`
    } `json:"signals"`
    Errors []struct {
        Engine  string `json:"engine"`
        Message string `json:"message"`
    } `json:"errors"`
    TotalMs   int    `json:"total_ms"`
    Timestamp string `json:"timestamp"`
    CacheHit  bool   `json:"cache_hit"`
}

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

fmt.Printf("Name: %s\n", data.Name)
fmt.Printf("Score: %d/100 (%s)\n", data.Score, data.Status)
fmt.Printf("Summary: %s\n", data.Summary)

for _, engine := range data.Engines {
    fmt.Printf("\n%s: %d/100 (exact: %d, loose: %d)\n",
        engine.Engine, engine.Score, engine.ExactHits, engine.LooseHits)
    for _, match := range engine.TopMatches {
        fmt.Printf("  - %s (%s)\n", match.Title, match.Relevance)
    }
}

Notes

• The overall score is an aggregate across all engines queried
• The summary field is AI-generated and may vary between requests
• Per-engine scores may differ — the overall score balances across all engines
• No API key is required during beta (60 requests/minute rate limit)
• Responses may be cached; cache_hit indicates whether a cached response was returned
• The signals object provides structured boolean flags for quick programmatic checks
• Use engines to limit which search engines are queried (useful for faster responses or debugging)

📄 Raw markdown: /docs/api/name-search-presence.md