Search Language Filter

from perplexity import Perplexity

client = Perplexity()

response = client.search.create(
    query="artificial intelligence",
    max_results=10,
    search_language_filter=["en"]
)

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

import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

const response = await client.search.create({
  query: "artificial intelligence",
  max_results: 10,
  search_language_filter: ["en"]
});

for (const result of response.results) {
  console.log(`${result.title}: ${result.url}`);
}

curl -X POST 'https://api.perplexity.ai/search' \
  -H 'Authorization: Bearer $PERPLEXITY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "artificial intelligence",
    "max_results": 10,
    "search_language_filter": ["en"]
  }' | jq

from perplexity import Perplexity

client = Perplexity()

# Search for content in English, French, and German
response = client.search.create(
    query="renewable energy innovations",
    max_results=15,
    search_language_filter=["en", "fr", "de"]
)

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

import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

// Search for content in English, French, and German
const response = await client.search.create({
  query: "renewable energy innovations",
  max_results: 15,
  search_language_filter: ["en", "fr", "de"]
});

for (const result of response.results) {
  console.log(`${result.title}: ${result.url}`);
}

curl -X POST 'https://api.perplexity.ai/search' \
  -H 'Authorization: Bearer $PERPLEXITY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "renewable energy innovations",
    "max_results": 15,
    "search_language_filter": ["en", "fr", "de"]
  }' | jq

from perplexity import Perplexity

client = Perplexity()

# Search for Asian market news in Chinese, Japanese, and Korean
response = client.search.create(
    query="technology market trends",
    max_results=10,
    search_language_filter=["zh", "ja", "ko"]
)

# Search for European tech news in multiple European languages
eu_response = client.search.create(
    query="tech startups",
    max_results=10,
    search_language_filter=["en", "de", "fr", "es", "it"]
)

import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

// Search for Asian market news in Chinese, Japanese, and Korean
const response = await client.search.create({
  query: "technology market trends",
  max_results: 10,
  search_language_filter: ["zh", "ja", "ko"]
});

// Search for European tech news in multiple European languages
const euResponse = await client.search.create({
  query: "tech startups",
  max_results: 10,
  search_language_filter: ["en", "de", "fr", "es", "it"]
});

# Search for Asian market news
curl -X POST 'https://api.perplexity.ai/search' \
  -H 'Authorization: Bearer $PERPLEXITY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "technology market trends",
    "max_results": 10,
    "search_language_filter": ["zh", "ja", "ko"]
  }' | jq

from perplexity import Perplexity

client = Perplexity()

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

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

import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

// Combine language filter with date and domain filters
const response = await client.search.create({
  query: "climate change research",
  max_results: 20,
  search_language_filter: ["en", "de"],
  search_domain_filter: ["nature.com", "science.org"],
  search_recency_filter: "month"
});

for (const result of response.results) {
  console.log(`${result.title}`);
  console.log(`URL: ${result.url}`);
  console.log(`Date: ${result.date}`);
  console.log("---");
}

curl -X POST 'https://api.perplexity.ai/search' \
  -H 'Authorization: Bearer $PERPLEXITY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "query": "climate change research",
    "max_results": 20,
    "search_language_filter": ["en", "de"],
    "search_domain_filter": ["nature.com", "science.org"],
    "search_recency_filter": "month"
  }' | jq

import re

def validate_language_code(code):
    pattern = r'^[a-z]{2}$'
    return bool(re.match(pattern, code))

def validate_language_filters(codes):
    if len(codes) > 10:
        raise ValueError("Maximum 10 language codes allowed")
    
    for code in codes:
        if not validate_language_code(code):
            raise ValueError(f"Invalid language code: {code}")
    
    return True

# Usage
try:
    codes = ["en", "fr", "de"]
    validate_language_filters(codes)
    
    response = client.search.create(
        query="technology news",
        search_language_filter=codes
    )
except ValueError as e:
    print(f"Validation error: {e}")

function validateLanguageCode(code: string): boolean {
  const pattern = /^[a-z]{2}$/;
  return pattern.test(code);
}

function validateLanguageFilters(codes: string[]): void {
  if (codes.length > 10) {
    throw new Error("Maximum 10 language codes allowed");
  }
  
  for (const code of codes) {
    if (!validateLanguageCode(code)) {
      throw new Error(`Invalid language code: ${code}`);
    }
  }
}

// Usage
try {
  const codes = ["en", "fr", "de"];
  validateLanguageFilters(codes);
  
  const response = await client.search.create({
    query: "technology news",
    search_language_filter: codes
  });
} catch (error) {
  console.error("Validation error:", error.message);
}

from perplexity import Perplexity, BadRequestError

client = Perplexity()

def safe_language_search(query, languages):
    """
    Perform a language-filtered search with error handling.
    """
    try:
        # Validate language codes
        if not isinstance(languages, list):
            raise ValueError("Languages must be provided as a list")
        
        if len(languages) > 10:
            raise ValueError("Maximum 10 language codes allowed")
        
        # Validate each code format
        for lang in languages:
            if not isinstance(lang, str) or len(lang) != 2 or not lang.islower():
                raise ValueError(f"Invalid language code format: {lang}")
        
        # Perform search
        response = client.search.create(
            query=query,
            search_language_filter=languages,
            max_results=10
        )
        
        return response
        
    except ValueError as e:
        print(f"Validation error: {e}")
        return None
    except BadRequestError as e:
        print(f"API error: {e.message}")
        return None
    except Exception as e:
        print(f"Unexpected error: {e}")
        return None

# Usage
results = safe_language_search(
    "artificial intelligence",
    ["en", "fr", "de"]
)

if results:
    print(f"Found {len(results.results)} results")

import Perplexity from '@perplexity-ai/perplexity_ai';

const client = new Perplexity();

async function safeLanguageSearch(
  query: string,
  languages: string[]
): Promise<any | null> {
  try {
    // Validate language codes
    if (!Array.isArray(languages)) {
      throw new Error("Languages must be provided as an array");
    }
    
    if (languages.length > 10) {
      throw new Error("Maximum 10 language codes allowed");
    }
    
    // Validate each code format
    for (const lang of languages) {
      if (typeof lang !== 'string' || 
          lang.length !== 2 || 
          lang !== lang.toLowerCase()) {
        throw new Error(`Invalid language code format: ${lang}`);
      }
    }
    
    // Perform search
    const response = await client.search.create({
      query,
      search_language_filter: languages,
      max_results: 10
    });
    
    return response;
    
  } catch (error) {
    if (error instanceof Perplexity.BadRequestError) {
      console.error("API error:", error.message);
    } else if (error instanceof Error) {
      console.error("Error:", error.message);
    }
    return null;
  }
}

// Usage
const results = await safeLanguageSearch(
  "artificial intelligence",
  ["en", "fr", "de"]
);

if (results) {
  console.log(`Found ${results.results.length} results`);
}