> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orthogonal.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Use Cases

> Real-world examples of chaining multiple APIs for complete workflows

These examples show how to combine multiple APIs through Orthogonal for common workflows. Each use case chains 2-4 APIs to accomplish a complete task.

## 1. Lead Research & Enrichment

**Goal:** Research a target company and build a complete profile of key contacts.

**APIs used:** LinkUp (AI search) → Apollo (enrichment) → Hunter (email finding)

<CodeGroup>
  ```javascript Node.js theme={null}
  const ORTH_KEY = process.env.ORTHOGONAL_API_KEY;

  async function run(api, path, body) {
    const res = await fetch('https://api.orthogonal.com/v1/run', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${ORTH_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ api, path, body })
    });
    return res.json();
  }

  async function researchLead(company) {
    // Step 1: Research the company with AI search
    const research = await run('linkup', '/search', {
      q: `${company} company funding valuation news 2026`,
      depth: 'standard'
    });
    
    // Step 2: Find contacts at the company
    const contacts = await run('hunter', '/domain-search', {
      domain: `${company}.com`
    });
    
    // Step 3: Enrich the top contact
    const topContact = contacts.data?.data?.emails?.[0];
    if (topContact?.value) {
      const enriched = await run('apollo', '/v1/people/match', {
        email: topContact.value
      });
      return { research: research.data, contact: enriched.data };
    }
    
    return { research: research.data, contacts: contacts.data };
  }


  const result = await researchLead('stripe');
  ```

  ```python Python theme={null}
  import requests
  import os

  ORTH_KEY = os.environ['ORTHOGONAL_API_KEY']

  def run(api, path, body):
      return requests.post(
          'https://api.orthogonal.com/v1/run',
          headers={'Authorization': f'Bearer {ORTH_KEY}'},
          json={'api': api, 'path': path, 'body': body}
      ).json()

  def research_lead(company):
      # Step 1: Research the company with AI search
      research = run('linkup', '/search', {
          'q': f'{company} company funding valuation news 2026',
          'depth': 'standard'
      })
      
      # Step 2: Find contacts at the company
      contacts = run('hunter', '/domain-search', {
          'domain': f'{company}.com'
      })
      
      # Step 3: Enrich the top contact
      emails = contacts.get('data', {}).get('data', {}).get('emails', [])
      if emails:
          enriched = run('apollo', '/v1/people/match', {
              'email': emails[0]['value']
          })
          return {'research': research['data'], 'contact': enriched['data']}
      
      return {'research': research['data'], 'contacts': contacts['data']}


  result = research_lead('stripe')
  ```
</CodeGroup>

***

## 2. Competitor Social Intelligence

**Goal:** Monitor a competitor's social media presence and extract brand assets.

**APIs used:** Shofo (social scraping) → Brand.dev (brand extraction) → Olostep (web scraping)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function analyzeCompetitor(domain, linkedinSlug) {
    // Step 1: Get their recent LinkedIn posts
    const posts = await run('shofo', '/linkedin/company-posts', {
      company_url: `https://linkedin.com/company/${linkedinSlug}`
    });
    
    // Step 2: Extract brand assets - logos, colors
    const brand = await run('brand-dev', '/v1/brand/retrieve', {
      domain: domain
    });
    
    // Step 3: Scrape their pricing page
    const pricing = await run('olostep', '/v1/scrapes', {
      url_to_scrape: `https://${domain}/pricing`,
      formats: ['markdown']
    });
    
    return {
      socialActivity: posts.data,
      brandAssets: brand.data,
      pricingInfo: pricing.data
    };
  }


  const intel = await analyzeCompetitor('notion.so', 'notionhq');
  ```

  ```python Python theme={null}
  def analyze_competitor(domain, linkedin_slug):
      # Step 1: Get their recent LinkedIn posts
      posts = run('shofo', '/linkedin/company-posts', {
          'company_url': f'https://linkedin.com/company/{linkedin_slug}'
      })
      
      # Step 2: Extract brand assets - logos, colors
      brand = run('brand-dev', '/v1/brand/retrieve', {
          'domain': domain
      })
      
      # Step 3: Scrape their pricing page
      pricing = run('olostep', '/v1/scrapes', {
          'url_to_scrape': f'https://{domain}/pricing',
          'formats': ['markdown']
      })
      
      return {
          'social_activity': posts['data'],
          'brand_assets': brand['data'],
          'pricing_info': pricing['data']
      }


  intel = analyze_competitor('notion.so', 'notionhq')
  ```
</CodeGroup>

***

## 3. Event-Based Prospecting

**Goal:** Find people who recently engaged with relevant content and enrich them for outreach.

**APIs used:** Fiber (people search) → Shofo (social activity) → Tomba (email finding)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function findEngagedProspects(criteria) {
    // Step 1: Find people matching your ICP
    const prospects = await run('fiber', '/v1/natural-language-search/profiles', {
      query: criteria,
      limit: 10
    });
    
    const enrichedProspects = [];
    
    for (const person of prospects.data?.profiles || []) {
      // Step 2: Check their recent LinkedIn activity
      const activity = await run('shofo', '/linkedin/user-posts', {
        profile_url: person.linkedin_url
      });
      
      // Step 3: Find their email
      const email = await run('tomba', '/v1/linkedin', {
        url: person.linkedin_url
      });
      
      enrichedProspects.push({
        ...person,
        recentPosts: activity.data?.posts?.slice(0, 3),
        email: email.data?.data?.email
      });
    }
    
    return enrichedProspects;
  }


  const prospects = await findEngagedProspects(
    'VP of Sales at Series B SaaS companies in San Francisco'
  );
  ```

  ```python Python theme={null}
  def find_engaged_prospects(criteria):
      # Step 1: Find people matching your ICP
      prospects = run('fiber', '/v1/natural-language-search/profiles', {
          'query': criteria,
          'limit': 10
      })
      
      enriched_prospects = []
      
      for person in prospects.get('data', {}).get('profiles', []):
          # Step 2: Check their recent LinkedIn activity
          activity = run('shofo', '/linkedin/user-posts', {
              'profile_url': person['linkedin_url']
          })
          
          # Step 3: Find their email
          email = run('tomba', '/v1/linkedin', {
              'url': person['linkedin_url']
          })
          
          enriched_prospects.append({
              **person,
              'recent_posts': activity.get('data', {}).get('posts', [])[:3],
              'email': email.get('data', {}).get('data', {}).get('email')
          })
      
      return enriched_prospects


  prospects = find_engaged_prospects(
      'VP of Sales at Series B SaaS companies in San Francisco'
  )
  ```
</CodeGroup>

***

## 4. Account-Based Marketing Research

**Goal:** Deep-dive on a target account - company intel, key people, and their social presence.

**APIs used:** Brand.dev (company data) → Fiber (find employees) → Apollo (enrich contacts)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function abmResearch(targetDomain) {
    // Step 1: Get company brand info and products
    const company = await run('brand-dev', '/v1/brand/retrieve', {
      domain: targetDomain
    });
    
    // Step 2: Find decision makers
    const people = await run('fiber', '/v1/natural-language-search/profiles', {
      query: `executives and VPs at ${targetDomain} company`,
      limit: 5
    });
    
    // Step 3: Enrich each person with contact details
    const enrichedPeople = [];
    for (const person of people.data?.profiles || []) {
      const enriched = await run('apollo', '/v1/people/match', {
        linkedin_url: person.linkedin_url
      });
      enrichedPeople.push({
        ...person,
        contact: enriched.data?.person
      });
    }
    
    return {
      company: company.data,
      decisionMakers: enrichedPeople
    };
  }


  const account = await abmResearch('figma.com');
  ```

  ```python Python theme={null}
  def abm_research(target_domain):
      # Step 1: Get company brand info and products
      company = run('brand-dev', '/v1/brand/retrieve', {
          'domain': target_domain
      })
      
      # Step 2: Find decision makers
      people = run('fiber', '/v1/natural-language-search/profiles', {
          'query': f'executives and VPs at {target_domain} company',
          'limit': 5
      })
      
      # Step 3: Enrich each person with contact details
      enriched_people = []
      for person in people.get('data', {}).get('profiles', []):
          enriched = run('apollo', '/v1/people/match', {
              'linkedin_url': person['linkedin_url']
          })
          enriched_people.append({
              **person,
              'contact': enriched.get('data', {}).get('person')
          })
      
      return {
          'company': company['data'],
          'decision_makers': enriched_people
      }


  account = abm_research('figma.com')
  ```
</CodeGroup>

***

## 5. Content & Trigger Monitoring

**Goal:** Monitor social channels for buying signals and company news.

**APIs used:** Shofo (X/Twitter monitoring) → LinkUp (news search) → Riveter (structured extraction)

<CodeGroup>
  ```javascript Node.js theme={null}
  async function monitorTriggers(companyHandle, domain) {
    // Step 1: Get recent tweets mentioning the company
    const tweets = await run('shofo', '/x/user-posts', {
      username: companyHandle
    });
    
    // Step 2: Search for recent news/announcements
    const news = await run('linkup', '/search', {
      q: `${domain} announcement funding launch 2026`,
      depth: 'standard'
    });
    
    // Step 3: Extract structured triggers from the news
    const triggers = await run('riveter', '/v1/run', {
      input: news.data?.results?.map(r => r.content).join('\n\n'),
      output_schema: {
        type: 'object',
        properties: {
          funding_events: { type: 'array', items: { type: 'string' } },
          product_launches: { type: 'array', items: { type: 'string' } },
          hiring_signals: { type: 'array', items: { type: 'string' } },
          expansion_news: { type: 'array', items: { type: 'string' } }
        }
      }
    });
    
    return {
      socialActivity: tweets.data,
      news: news.data,
      triggers: triggers.data
    };
  }


  const signals = await monitorTriggers('stripe', 'stripe.com');
  ```

  ```python Python theme={null}
  def monitor_triggers(company_handle, domain):
      # Step 1: Get recent tweets mentioning the company
      tweets = run('shofo', '/x/user-posts', {
          'username': company_handle
      })
      
      # Step 2: Search for recent news/announcements
      news = run('linkup', '/search', {
          'q': f'{domain} announcement funding launch 2026',
          'depth': 'standard'
      })
      
      # Step 3: Extract structured triggers from the news
      content = '\n\n'.join([r.get('content', '') for r in news.get('data', {}).get('results', [])])
      triggers = run('riveter', '/v1/run', {
          'input': content,
          'output_schema': {
              'type': 'object',
              'properties': {
                  'funding_events': {'type': 'array', 'items': {'type': 'string'}},
                  'product_launches': {'type': 'array', 'items': {'type': 'string'}},
                  'hiring_signals': {'type': 'array', 'items': {'type': 'string'}},
                  'expansion_news': {'type': 'array', 'items': {'type': 'string'}}
              }
          }
      })
      
      return {
          'social_activity': tweets['data'],
          'news': news['data'],
          'triggers': triggers['data']
      }


  signals = monitor_triggers('stripe', 'stripe.com')
  ```
</CodeGroup>