Skip to main content
The search_domain_filter parameter allows you to limit search results to specific domains or URLs, enabling focused research from trusted sources. You can also exclude domains by prefixing them with a - character.
Domain filters support both allowlisting (include specific domains) and denylisting (exclude specific domains). You can specify up to 20 domains per request. Domains should be provided without the protocol (e.g., “nature.com” not “https://nature.com”).

​
Overview

The domain filter for the Search API allows you to control which sources appear in your search results by limiting them to specific domains or excluding unwanted domains. This is particularly useful when you need to:
  • Focus research on authoritative or trusted sources
  • Search within specific publication networks or organizations
  • Exclude unreliable or off-topic domains from results
  • Build domain-specific search applications
  • Conduct competitive research within specific industry domains
The search_domain_filter parameter accepts an array of domain strings and supports two filtering modes:

​
Allowlisting (Include Domains)

Allowlisting restricts results to only the specified domains. This is useful when you want to search exclusively within trusted or relevant sources. 
"search_domain_filter": ["nature.com", "science.org", "cell.com"]

​
Denylisting (Exclude Domains)

Denylisting excludes specific domains from your results by prefixing them with a - character. This is useful when you want broad coverage but need to filter out specific sources. 
"search_domain_filter": ["-example.com", "-spam-site.net"]
You cannot combine allowlisting and denylisting in the same request. Use either inclusion (no prefix) or exclusion (- prefix), but not both.

​
Examples

1. Allowlisting Academic Sources This example limits search results to authoritative academic publishers: Request Example 
from perplexity import Perplexity

client = Perplexity()

response = client.search.create(
    query="climate change research",
    max_results=10,
    search_domain_filter=[
        "nature.com",
        "science.org",
        "cell.com"
    ]
)

for result in response.results:
    print(f"{result.title}: {result.url}")
2. Denylisting Unwanted Sources Exclude specific domains from your search results: 
from perplexity import Perplexity

client = Perplexity()

response = client.search.create(
    query="artificial intelligence news",
    max_results=15,
    search_domain_filter=[
        "-socialmedia.com",
        "-clickbait-news.net"
    ]
)

for result in response.results:
    print(f"{result.title}")
    print(f"URL: {result.url}")
    print("---")
3. Tech News Sources Search across major technology news websites: 
from perplexity import Perplexity

client = Perplexity()

response = client.search.create(
    query="latest tech trends 2025",
    max_results=10,
    search_domain_filter=[
        "techcrunch.com",
        "theverge.com",
        "arstechnica.com",
        "wired.com"
    ]
)

for result in response.results:
    print(f"{result.title}")
    print(f"Source: {result.url}")
    print(f"Date: {result.date}")
    print("---")
4. Combining Domain Filter with Other Filters Domain filters work seamlessly with other search parameters for precise control: 
from perplexity import Perplexity

client = Perplexity()

# Combine domain filter with date and language filters
response = client.search.create(
    query="quantum computing breakthroughs",
    max_results=20,
    search_domain_filter=[
        "nature.com",
        "science.org",
        "arxiv.org"
    ],
    search_recency_filter="month",
    search_language_filter=["en"]
)

for result in response.results:
    print(f"{result.title}")
    print(f"URL: {result.url}")
    print(f"Date: {result.date}")
    print("---")

​
Parameter Reference

​
search_domain_filter

  • Type: Array of strings
  • Format: Domain names without protocol (e.g., “example.com”)
  • Description: Filters search results to only include (allowlist) or exclude (denylist) content from specified domains
  • Optional: Yes
  • Maximum: 20 domains per request
  • Allowlisting Example: "search_domain_filter": ["nature.com", "science.org"]
  • Denylisting Example: "search_domain_filter": ["-spam.com", "-ads.net"]

​
Domain Format Guidelines

Correct Domain Formats:
  • "nature.com" - Root domain
  • "blog.example.com" - Subdomain
  • "arxiv.org" - Root domain
  • "-unwanted.net" - Denylist with prefix
Incorrect Domain Formats:
  • ❌ "https://nature.com" - Don’t include protocol
  • ❌ "nature.com/" - Don’t include trailing slash
  • ❌ "nature.com/articles" - Don’t include path
  • ❌ "www.nature.com" - Avoid www prefix (use root domain)

​
Best Practices

​
Domain Selection Strategy

  • Use Root Domains: Specify root domains (e.g., “nature.com”) rather than subdomains or specific paths. The filter will match all content from that domain.
  • Be Specific: Choose domains that are directly relevant to your search query to ensure high-quality results.
  • Quality Over Quantity: Using fewer, highly relevant domains often produces better results than maximizing the 20-domain limit.
  • Consider Domain Authority: Prioritize authoritative sources in your field for more reliable information.

​
Filtering Mode Selection

  • Allowlisting: Use when you have a specific set of trusted sources you want to search within (e.g., academic research, official documentation).
  • Denylisting: Use when you want broad coverage but need to exclude known problematic sources (e.g., spam sites, social media).
  • Never Mix: Do not combine allowlisting and denylisting in the same request. Choose one approach based on your needs.

​
Client-Side Validation

Validate domain formats on the client side before sending requests: 
import re

def validate_domain(domain):
    """Validate domain format."""
    # Remove denylist prefix if present
    clean_domain = domain.lstrip('-')

    # Basic domain validation pattern
    pattern = r'^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$'
    return bool(re.match(pattern, clean_domain))

def validate_domain_filter(domains):
    """Validate domain filter array."""
    if len(domains) > 20:
        raise ValueError("Maximum 20 domains allowed")

    # Check for mixed allowlist/denylist
    has_allowlist = any(not d.startswith('-') for d in domains)
    has_denylist = any(d.startswith('-') for d in domains)

    if has_allowlist and has_denylist:
        raise ValueError("Cannot mix allowlisting and denylisting")

    for domain in domains:
        if not validate_domain(domain):
            raise ValueError(f"Invalid domain format: {domain}")

    return True

# Usage
try:
    domains = ["nature.com", "science.org", "arxiv.org"]
    validate_domain_filter(domains)

    response = client.search.create(
        query="research topic",
        search_domain_filter=domains
    )
except ValueError as e:
    print(f"Validation error: {e}")

​
Performance Considerations

  • Result Availability: Narrowing to specific domains may reduce the number of available results. Be prepared to handle cases where fewer results are returned than requested.
  • Domain Coverage: Ensure the domains you specify actually contain content relevant to your query. Overly restrictive filters may return zero results.
  • Combination Effects: Domain filters combined with other restrictive filters (date, language) can significantly reduce result counts.
For best results, combine domain filtering with other filters like search_recency_filter or search_language_filter to narrow down your search to highly relevant, timely content from your target sources.