Exa Entities

Exa Entity Search

Quick Reference

Essential Patterns

Company Search

from exa_py import Exa

exa = Exa()

results = exa.search_and_contents(
    "AI startups in healthcare series A funding",
    category="company",
    num_results=20,
    text=True
)

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

People Search

results = exa.search_and_contents(
    "machine learning engineers San Francisco",
    category="linkedin_profile",
    num_results=20,
    text=True
)

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

Websets for Lead Generation

# Create a webset for company collection
webset = exa.websets.create(
    name="AI Healthcare Companies",
    search_query="AI healthcare startups",
    category="company",
    max_results=100
)

# Monitor for new matches
exa.websets.add_monitor(
    webset_id=webset.id,
    schedule="daily"
)

Category Reference

Common Mistakes

1. Not using category filter - Always set category="company" or category="linkedin_profile" for entity search 2. Expecting structured data - Exa returns web pages; parse text for structured fields 3. Over-broad queries - Add location, industry, or role specifics for better results 4. Ignoring rate limits - Batch requests and implement backoff for large-scale collection 5. Missing domain filters - Use include_domains=["linkedin.com"] for profile-only results

Company Search Reference

Table of Contents

• Basic Company Search
• Filtering Companies
• Company Research Patterns
• Competitive Intelligence
• Lead Generation

---

Basic Company Search

Using Company Category

from exa_py import Exa

exa = Exa()

# Search for companies by description
results = exa.search_and_contents(
    "AI startups building developer tools",
    category="company",
    num_results=20,
    text=True
)

for company in results.results:
    print(f"Company: {company.title}")
    print(f"URL: {company.url}")
    print(f"Description: {company.text[:300]}...")
    print()

TypeScript

import Exa from "exa-js";

const exa = new Exa();

const results = await exa.searchAndContents(
  "AI startups building developer tools",
  {
    category: "company",
    numResults: 20,
    text: true,
  }
);

---

Filtering Companies

By Industry and Location

# Healthcare AI in San Francisco
results = exa.search_and_contents(
    "healthcare AI startup San Francisco",
    category="company",
    num_results=20,
    text=True
)

# Fintech in London
results = exa.search_and_contents(
    "fintech company London UK",
    category="company",
    num_results=20,
    text=True
)

By Funding Stage

# Series A companies
results = exa.search_and_contents(
    "series A startup AI infrastructure",
    category="company",
    num_results=20,
    text=True,
    start_published_date="2023-01-01"  # Recent funding
)

# Seed stage
results = exa.search_and_contents(
    "seed funded startup machine learning",
    category="company",
    num_results=20,
    text=True
)

By Company Size

# Enterprise companies
results = exa.search_and_contents(
    "enterprise software company Fortune 500",
    category="company",
    num_results=20,
    text=True
)

# Small startups
results = exa.search_and_contents(
    "early stage startup founded 2023",
    category="company",
    num_results=20,
    text=True
)

Combining Domain Filters

# Only include specific company sites
results = exa.search_and_contents(
    "AI company",
    category="company",
    num_results=20,
    exclude_domains=["linkedin.com", "crunchbase.com", "glassdoor.com"],
    text=True
)

---

Company Research Patterns

Company Profile Extraction

def get_company_profile(company_name):
    """Research a specific company."""
    results = exa.search_and_contents(
        f"{company_name} company about us",
        category="company",
        num_results=5,
        text=True,
        summary=True
    )

    if results.results:
        company = results.results[0]
        return {
            "name": company_name,
            "url": company.url,
            "summary": company.summary,
            "full_text": company.text
        }
    return None

Industry Overview

def research_industry(industry, limit=50):
    """Get overview of companies in an industry."""
    results = exa.search_and_contents(
        f"{industry} companies startups",
        category="company",
        num_results=limit,
        summary=True
    )

    return {
        "industry": industry,
        "company_count": len(results.results),
        "companies": [
            {
                "name": r.title,
                "url": r.url,
                "summary": r.summary
            }
            for r in results.results
        ]
    }

Technology Stack Research

def find_companies_using_tech(technology):
    """Find companies using specific technology."""
    results = exa.search_and_contents(
        f"company using {technology} tech stack",
        category="company",
        num_results=30,
        text=True,
        include_text=[technology]  # Ensure tech is mentioned
    )

    return results.results

---

Competitive Intelligence

Find Competitors

def find_competitors(company_url, num_competitors=10):
    """Find similar companies (competitors)."""
    similar = exa.find_similar_and_contents(
        company_url,
        num_results=num_competitors,
        category="company",
        exclude_source_domain=True,
        text=True,
        summary=True
    )

    return [
        {
            "name": r.title,
            "url": r.url,
            "summary": r.summary
        }
        for r in similar.results
    ]

Market Landscape

def map_market_landscape(market_description):
    """Map companies in a market segment."""

    # Search for different company types
    segments = {
        "leaders": f"{market_description} market leader enterprise",
        "challengers": f"{market_description} growing startup series B C",
        "emerging": f"{market_description} new startup seed series A"
    }

    landscape = {}
    for segment, query in segments.items():
        results = exa.search_and_contents(
            query,
            category="company",
            num_results=15,
            summary=True
        )
        landscape[segment] = [
            {"name": r.title, "url": r.url, "summary": r.summary}
            for r in results.results
        ]

    return landscape

Track Company News

def get_company_news(company_name, days=30):
    """Get recent news about a company."""
    from datetime import datetime, timedelta

    start_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")

    results = exa.search_and_contents(
        f"{company_name} news announcement",
        category="news",
        num_results=20,
        start_published_date=start_date,
        text=True,
        highlights=True
    )

    return [
        {
            "title": r.title,
            "url": r.url,
            "date": r.published_date,
            "highlights": r.highlights
        }
        for r in results.results
    ]

---

Lead Generation

Build Prospect List

def build_prospect_list(criteria, limit=100):
    """Build a list of company prospects."""
    query = " ".join([
        criteria.get("industry", ""),
        criteria.get("location", ""),
        criteria.get("size", ""),
        criteria.get("technology", ""),
        "company"
    ])

    results = exa.search_and_contents(
        query,
        category="company",
        num_results=limit,
        text=True,
        summary=True
    )

    prospects = []
    for r in results.results:
        prospects.append({
            "company_name": r.title,
            "website": r.url,
            "summary": r.summary,
            "description": r.text[:500] if r.text else None
        })

    return prospects

# Example usage
prospects = build_prospect_list({
    "industry": "fintech",
    "location": "New York",
    "size": "startup",
    "technology": "AI"
})

Enrich Company Data

def enrich_company(company_url):
    """Get additional data for a company."""
    contents = exa.get_contents(
        urls=[company_url],
        text=True,
        summary=True
    )

    if contents.results:
        company = contents.results[0]

        # Search for additional info
        news = exa.search_and_contents(
            f"site:{company_url} news",
            num_results=5,
            text=True
        )

        return {
            "url": company_url,
            "title": company.title,
            "summary": company.summary,
            "full_description": company.text,
            "recent_news": [r.title for r in news.results]
        }

    return None

Export to CSV

import csv

def export_companies_to_csv(companies, filename="companies.csv"):
    """Export company list to CSV."""
    if not companies:
        return

    fieldnames = ["company_name", "website", "summary"]

    with open(filename, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        for company in companies:
            writer.writerow({
                "company_name": company.get("company_name", ""),
                "website": company.get("website", ""),
                "summary": company.get("summary", "")[:500]
            })

People Search Reference

Table of Contents

• Basic People Search
• LinkedIn Profile Search
• Filtering Profiles
• Recruiting Patterns
• Professional Research

---

Basic People Search

Exa indexes over 1 billion professional profiles, including LinkedIn.

Using LinkedIn Category

from exa_py import Exa

exa = Exa()

results = exa.search_and_contents(
    "software engineer machine learning Python",
    category="linkedin_profile",
    num_results=20,
    text=True
)

for profile in results.results:
    print(f"Name: {profile.title}")
    print(f"Profile: {profile.url}")
    print(f"Bio: {profile.text[:200]}...")
    print()

TypeScript

import Exa from "exa-js";

const exa = new Exa();

const results = await exa.searchAndContents(
  "software engineer machine learning Python",
  {
    category: "linkedin_profile",
    numResults: 20,
    text: true,
  }
);

---

LinkedIn Profile Search

By Role and Skills

# Senior engineers with specific skills
results = exa.search_and_contents(
    "senior software engineer React TypeScript Node.js",
    category="linkedin_profile",
    num_results=30,
    text=True
)

By Company

# Find people at specific companies
results = exa.search_and_contents(
    "engineer at Google machine learning",
    category="linkedin_profile",
    num_results=20,
    text=True
)

# Alumni search
results = exa.search_and_contents(
    "former Google engineer startup founder",
    category="linkedin_profile",
    num_results=20,
    text=True
)

By Location

# Profiles in specific locations
results = exa.search_and_contents(
    "data scientist San Francisco Bay Area",
    category="linkedin_profile",
    num_results=30,
    text=True
)

# Remote-friendly
results = exa.search_and_contents(
    "remote software engineer distributed team",
    category="linkedin_profile",
    num_results=30,
    text=True
)

---

Filtering Profiles

Domain Filtering

# Only LinkedIn profiles
results = exa.search_and_contents(
    "product manager fintech",
    category="linkedin_profile",
    include_domains=["linkedin.com"],
    num_results=30,
    text=True
)

# Personal sites and portfolios
results = exa.search_and_contents(
    "UX designer portfolio",
    category="personal_site",
    num_results=30,
    text=True
)

By Experience Level

# Senior/leadership
results = exa.search_and_contents(
    "VP Engineering CTO tech startup",
    category="linkedin_profile",
    num_results=20,
    text=True
)

# Mid-level
results = exa.search_and_contents(
    "senior software engineer 5 years experience",
    category="linkedin_profile",
    num_results=30,
    text=True
)

# Entry-level
results = exa.search_and_contents(
    "junior developer bootcamp graduate",
    category="linkedin_profile",
    num_results=30,
    text=True
)

GitHub Developer Search

# Find developers by their GitHub presence
results = exa.search_and_contents(
    "open source contributor Rust systems programming",
    category="github",
    num_results=20,
    text=True
)

---

Recruiting Patterns

Candidate Search

def search_candidates(role, skills, location=None, limit=50):
    """Search for job candidates."""
    query_parts = [role] + skills
    if location:
        query_parts.append(location)

    query = " ".join(query_parts)

    results = exa.search_and_contents(
        query,
        category="linkedin_profile",
        num_results=limit,
        text=True
    )

    candidates = []
    for r in results.results:
        candidates.append({
            "name": r.title,
            "profile_url": r.url,
            "bio": r.text[:500] if r.text else None
        })

    return candidates

# Example
candidates = search_candidates(
    role="senior backend engineer",
    skills=["Python", "Django", "PostgreSQL"],
    location="New York"
)

Find Similar Profiles

def find_similar_candidates(profile_url, limit=20):
    """Find candidates similar to a known good profile."""
    similar = exa.find_similar_and_contents(
        profile_url,
        num_results=limit,
        category="linkedin_profile",
        exclude_source_domain=False,  # Keep LinkedIn results
        text=True
    )

    return [
        {
            "name": r.title,
            "profile_url": r.url,
            "bio": r.text[:500] if r.text else None
        }
        for r in similar.results
    ]

Build Talent Pipeline

def build_talent_pipeline(job_requirements):
    """Build a pipeline of potential candidates."""
    pipeline = {
        "active_seekers": [],
        "passive_candidates": [],
        "leadership": []
    }

    # Active job seekers
    active = exa.search_and_contents(
        f"{job_requirements['role']} open to opportunities seeking",
        category="linkedin_profile",
        num_results=30,
        text=True
    )
    pipeline["active_seekers"] = [
        {"name": r.title, "url": r.url}
        for r in active.results
    ]

    # Passive candidates at target companies
    if job_requirements.get("target_companies"):
        for company in job_requirements["target_companies"][:3]:
            passive = exa.search_and_contents(
                f"{job_requirements['role']} at {company}",
                category="linkedin_profile",
                num_results=10,
                text=True
            )
            pipeline["passive_candidates"].extend([
                {"name": r.title, "url": r.url, "company": company}
                for r in passive.results
            ])

    # Leadership candidates
    leadership = exa.search_and_contents(
        f"head of {job_requirements['role']} director manager",
        category="linkedin_profile",
        num_results=20,
        text=True
    )
    pipeline["leadership"] = [
        {"name": r.title, "url": r.url}
        for r in leadership.results
    ]

    return pipeline

---

Professional Research

Expert Finding

def find_experts(domain, num_experts=20):
    """Find experts in a specific domain."""
    # Search for thought leaders
    results = exa.search_and_contents(
        f"{domain} expert thought leader speaker author",
        category="linkedin_profile",
        num_results=num_experts,
        text=True,
        summary=True
    )

    return [
        {
            "name": r.title,
            "profile": r.url,
            "summary": r.summary,
            "expertise": domain
        }
        for r in results.results
    ]

Team Research

def research_company_team(company_name):
    """Research key people at a company."""
    roles = ["CEO", "CTO", "VP Engineering", "Head of Product"]

    team = {}
    for role in roles:
        results = exa.search_and_contents(
            f"{role} at {company_name}",
            category="linkedin_profile",
            num_results=3,
            text=True
        )
        if results.results:
            team[role] = {
                "name": results.results[0].title,
                "profile": results.results[0].url
            }

    return team

Investor/Advisor Search

def find_investors(industry, stage="seed"):
    """Find investors active in an industry."""
    results = exa.search_and_contents(
        f"angel investor VC partner {industry} {stage}",
        category="linkedin_profile",
        num_results=30,
        text=True
    )

    investors = []
    for r in results.results:
        investors.append({
            "name": r.title,
            "profile": r.url,
            "bio": r.text[:300] if r.text else None
        })

    return investors

Conference Speaker Research

def find_speakers(topic, conference_type="tech"):
    """Find potential speakers for events."""
    results = exa.search_and_contents(
        f"{topic} speaker {conference_type} conference keynote",
        category="linkedin_profile",
        num_results=30,
        text=True,
        summary=True
    )

    return [
        {
            "name": r.title,
            "profile": r.url,
            "summary": r.summary
        }
        for r in results.results
    ]

Websets API Reference

Table of Contents

• Overview
• Creating Websets
• Managing Websets
• Monitoring
• Enrichment
• Export and Integration

---

Overview

Websets enable web data collection, verification, and processing at scale:

• Search-based collection: Automatically gather data matching your criteria
• Monitoring: Get notified when new matches appear
• Enrichment: Enhance collected data with additional information
• Webhooks: Integrate with your systems in real-time

---

Creating Websets

Basic Webset

from exa_py import Exa

exa = Exa()

# Create a webset for company collection
webset = exa.websets.create(
    name="AI Startups 2024",
    description="AI companies founded in 2024",
    search_query="AI startup founded 2024",
    category="company",
    max_results=500
)

print(f"Webset ID: {webset.id}")
print(f"Status: {webset.status}")

With Advanced Filters

webset = exa.websets.create(
    name="Healthcare AI Series A",
    description="Healthcare AI companies with Series A funding",
    search_query="healthcare AI startup series A funding",
    category="company",
    include_domains=None,  # All domains
    exclude_domains=["linkedin.com", "crunchbase.com"],
    start_published_date="2023-01-01",
    max_results=200
)

People Webset

webset = exa.websets.create(
    name="ML Engineers SF",
    description="Machine learning engineers in San Francisco",
    search_query="machine learning engineer San Francisco",
    category="linkedin_profile",
    max_results=1000
)

---

Managing Websets

List Websets

# Get all websets
websets = exa.websets.list()

for ws in websets:
    print(f"Name: {ws.name}")
    print(f"ID: {ws.id}")
    print(f"Status: {ws.status}")
    print(f"Items: {ws.item_count}")
    print()

Get Webset Details

webset = exa.websets.get(webset_id="ws_abc123")

print(f"Name: {webset.name}")
print(f"Status: {webset.status}")
print(f"Created: {webset.created_at}")
print(f"Item count: {webset.item_count}")

Get Webset Items

# Get items from a webset
items = exa.websets.get_items(
    webset_id="ws_abc123",
    limit=100,
    offset=0
)

for item in items:
    print(f"URL: {item.url}")
    print(f"Title: {item.title}")
    print(f"Added: {item.added_at}")

Update Webset

updated = exa.websets.update(
    webset_id="ws_abc123",
    name="Updated Name",
    description="Updated description"
)

Delete Webset

exa.websets.delete(webset_id="ws_abc123")

---

Monitoring

Set up monitors to track new matches over time.

Create Monitor

# Daily monitoring for new results
monitor = exa.websets.add_monitor(
    webset_id="ws_abc123",
    schedule="daily",  # or "hourly", "weekly"
    enabled=True
)

print(f"Monitor ID: {monitor.id}")
print(f"Schedule: {monitor.schedule}")

With Webhook Notification

monitor = exa.websets.add_monitor(
    webset_id="ws_abc123",
    schedule="hourly",
    webhook_url="https://your-app.com/webhooks/exa",
    webhook_secret="your-secret-key"
)

Manage Monitors

# List monitors for a webset
monitors = exa.websets.list_monitors(webset_id="ws_abc123")

# Pause monitor
exa.websets.update_monitor(
    monitor_id="mon_xyz",
    enabled=False
)

# Delete monitor
exa.websets.delete_monitor(monitor_id="mon_xyz")

Webhook Payload Structure

{
  "event": "new_items",
  "webset_id": "ws_abc123",
  "webset_name": "AI Startups 2024",
  "new_items_count": 5,
  "items": [
    {
      "url": "https://example.com",
      "title": "New AI Startup",
      "added_at": "2024-01-15T10:30:00Z"
    }
  ],
  "timestamp": "2024-01-15T10:30:00Z"
}

Verify Webhook Signature

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    """Verify Exa webhook signature."""
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()

    return hmac.compare_digest(signature, expected)

# In your webhook handler
@app.post("/webhooks/exa")
def handle_webhook(request):
    signature = request.headers.get("X-Exa-Signature")
    payload = request.body

    if not verify_webhook(payload, signature, WEBHOOK_SECRET):
        return {"error": "Invalid signature"}, 401

    data = json.loads(payload)
    # Process new items
    for item in data["items"]:
        process_new_item(item)

    return {"status": "ok"}

---

Enrichment

Enhance webset items with additional data.

Basic Enrichment

# Enrich items with full content
enriched = exa.websets.enrich(
    webset_id="ws_abc123",
    enrichments=["text", "summary"]
)

# Get enriched items
items = exa.websets.get_items(webset_id="ws_abc123")

for item in items:
    print(f"URL: {item.url}")
    print(f"Summary: {item.summary}")
    print(f"Full text: {item.text[:500]}")

Custom Enrichment Fields

enriched = exa.websets.enrich(
    webset_id="ws_abc123",
    enrichments={
        "text": True,
        "summary": True,
        "highlights": {"num_sentences": 3}
    }
)

---

Export and Integration

Export to CSV

# Export webset to CSV
export = exa.websets.export(
    webset_id="ws_abc123",
    format="csv"
)

# Download the export
with open("companies.csv", "wb") as f:
    f.write(export.content)

Export to JSON

export = exa.websets.export(
    webset_id="ws_abc123",
    format="json"
)

data = json.loads(export.content)

Import URLs

# Import existing URLs into a webset
exa.websets.import_urls(
    webset_id="ws_abc123",
    urls=[
        "https://company1.com",
        "https://company2.com",
        "https://company3.com"
    ]
)

Sync with Database

def sync_webset_to_database(webset_id, db):
    """Sync webset items to a database."""
    items = exa.websets.get_items(webset_id=webset_id)

    for item in items:
        db.upsert("companies", {
            "url": item.url,
            "title": item.title,
            "summary": item.summary,
            "added_at": item.added_at,
            "source": "exa_webset"
        })

---

Common Patterns

Lead Generation Pipeline

def create_lead_pipeline(industry, target_count=500):
    """Create a complete lead generation pipeline."""

    # 1. Create webset for companies
    webset = exa.websets.create(
        name=f"{industry} Companies",
        search_query=f"{industry} startup company",
        category="company",
        max_results=target_count
    )

    # 2. Set up daily monitoring
    monitor = exa.websets.add_monitor(
        webset_id=webset.id,
        schedule="daily",
        webhook_url="https://your-crm.com/webhooks/new-leads"
    )

    # 3. Enrich with content
    exa.websets.enrich(
        webset_id=webset.id,
        enrichments=["text", "summary"]
    )

    return {
        "webset_id": webset.id,
        "monitor_id": monitor.id,
        "status": "pipeline_created"
    }

Competitive Monitoring

def monitor_competitors(competitor_names):
    """Set up monitoring for competitor news."""

    for name in competitor_names:
        webset = exa.websets.create(
            name=f"{name} News",
            search_query=f"{name} news announcement",
            category="news",
            max_results=100
        )

        exa.websets.add_monitor(
            webset_id=webset.id,
            schedule="hourly",
            webhook_url="https://your-app.com/webhooks/competitor-news"
        )

Talent Pool Management

def create_talent_pool(role, skills, location):
    """Create and maintain a talent pool."""

    query = f"{role} {' '.join(skills)} {location}"

    webset = exa.websets.create(
        name=f"Talent Pool: {role}",
        search_query=query,
        category="linkedin_profile",
        max_results=1000
    )

    # Monitor for new profiles weekly
    exa.websets.add_monitor(
        webset_id=webset.id,
        schedule="weekly"
    )

    # Enrich with profile details
    exa.websets.enrich(
        webset_id=webset.id,
        enrichments=["text", "summary"]
    )

    return webset