Skip to main content

​
Find Career Page

Automatically discover a company’s careers or jobs page URL.

​
Method

services.company.careers.findPage(params);

​
Parameters

​
domain
string
Company domain (e.g., “acme.com”)
​
companyLinkedinUrl
string
Company LinkedIn URL
Provide at least one of: domain or companyLinkedinUrl

​
Returns

Returns a Promise with:
​
url
string
required
The URL of the careers page

​
Example

const careerPage = await services.company.careers.findPage({
   domain: "microsoft.com",
});

console.log(careerPage.url); // "https://careers.microsoft.com"

​
Scrape Job Postings

Extract structured job posting data from a careers page URL.

​
Method

services.company.careers.scrapeJobs(params);

​
Parameters

​
url
string
The URL of the careers page to scrape
​
exactMatchingOnly
boolean
default:false
Whether to only return exact matches (more precise but may miss some jobs)
​
maxJobs
number
Maximum number of jobs to return
​
recent
string
Filter by posting date. Options: - "24h" - Last 24 hours - "week" - Last week - "month" - Last month - "all"
  • All jobs (default)
​
scrapeDetails
boolean
default:false
Whether to scrape full job descriptions (slower but more detailed)

​
Returns

Returns a Promise with an array of job objects:
​
title
string
required
Job title
​
id
string
Job posting ID
​
location
string
Job location
​
description
string
Full job description (only if scrapeDetails: true)
​
datePosted
string
Date the job was posted

​
Example

// Find and scrape in one flow
const careerPage = await services.company.careers.findPage({
   domain: "acme.com",
});

const jobs = await services.company.careers.scrapeJobs({
   url: careerPage.url,
   recent: "month",
   maxJobs: 50,
});

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

jobs.forEach((job) => {
   console.log(`${job.title} - ${job.location}`);
   console.log(`Posted: ${job.datePosted}`);
});

​
Use Cases

​
Get Recent Job Postings

async function getRecentJobs(domain: string) {
   // Find career page
   const careerPage = await services.company.careers.findPage({ domain });

   // Get jobs from last week
   const jobs = await services.company.careers.scrapeJobs({
      url: careerPage.url,
      recent: "week",
   });

   return jobs;
}

const recentJobs = await getRecentJobs("stripe.com");
console.log(`${recentJobs.length} jobs posted this week`);

async function analyzeHiring(domain: string) {
   const careerPage = await services.company.careers.findPage({ domain });

   const jobs = await services.company.careers.scrapeJobs({
      url: careerPage.url,
      recent: "all",
   });

   // Count by department (inferred from title)
   const departments = {
      engineering: 0,
      sales: 0,
      marketing: 0,
      product: 0,
      other: 0,
   };

   jobs.forEach((job) => {
      const title = job.title.toLowerCase();
      if (title.includes("engineer") || title.includes("developer")) {
         departments.engineering++;
      } else if (title.includes("sales") || title.includes("account")) {
         departments.sales++;
      } else if (title.includes("marketing")) {
         departments.marketing++;
      } else if (title.includes("product")) {
         departments.product++;
      } else {
         departments.other++;
      }
   });

   return {
      totalJobs: jobs.length,
      byDepartment: departments,
      locations: [...new Set(jobs.map((j) => j.location).filter(Boolean))],
   };
}

​
Find Specific Roles

async function findEngineeringRoles(domain: string) {
   const careerPage = await services.company.careers.findPage({ domain });

   const allJobs = await services.company.careers.scrapeJobs({
      url: careerPage.url,
      recent: "month",
   });

   // Filter for engineering roles
   const engineeringJobs = allJobs.filter((job) => {
      const title = job.title.toLowerCase();
      return title.includes("engineer") || title.includes("developer") || title.includes("software");
   });

   return engineeringJobs;
}

​
Get Full Job Details

async function getDetailedJobs(domain: string) {
   const careerPage = await services.company.careers.findPage({ domain });

   // Scrape with full descriptions
   const jobs = await services.company.careers.scrapeJobs({
      url: careerPage.url,
      recent: "week",
      scrapeDetails: true, // Get full descriptions
      maxJobs: 20, // Limit for performance
   });

   jobs.forEach((job) => {
      console.log(`\n${job.title}`);
      console.log(`Location: ${job.location}`);
      console.log(`Posted: ${job.datePosted}`);
      console.log(`\nDescription:\n${job.description}`);
   });

   return jobs;
}

​
Monitor New Postings

async function checkForNewJobs(domain: string, lastCheckDate: Date) {
   const careerPage = await services.company.careers.findPage({ domain });

   const jobs = await services.company.careers.scrapeJobs({
      url: careerPage.url,
      recent: "24h",
   });

   // Filter by date if needed
   const newJobs = jobs.filter((job) => {
      if (!job.datePosted) return true;
      const postDate = new Date(job.datePosted);
      return postDate > lastCheckDate;
   });

   if (newJobs.length > 0) {
      console.log(`${newJobs.length} new jobs found!`);
      newJobs.forEach((job) => {
         console.log(`- ${job.title} (${job.location})`);
      });
   }

   return newJobs;
}

​
Compare Hiring Across Companies

async function compareHiring(domains: string[]) {
   const results = await Promise.all(
      domains.map(async (domain) => {
         try {
            const careerPage = await services.company.careers.findPage({ domain });
            const jobs = await services.company.careers.scrapeJobs({
               url: careerPage.url,
               recent: "month",
            });

            return {
               company: domain,
               jobCount: jobs.length,
               jobs,
            };
         } catch (error) {
            console.error(`Failed to get jobs for ${domain}:`, error);
            return {
               company: domain,
               jobCount: 0,
               jobs: [],
            };
         }
      })
   );

   // Sort by job count
   results.sort((a, b) => b.jobCount - a.jobCount);

   console.log("\nHiring Activity:");
   results.forEach((r) => {
      console.log(`${r.company}: ${r.jobCount} open positions`);
   });

   return results;
}

await compareHiring(["stripe.com", "square.com", "plaid.com"]);

​
Best Practices

Performance: Set scrapeDetails: false (default) for faster scraping when you only need job titles and locations. Only enable it when you need full descriptions.
Performance: Scraping job pages can be slow for large companies with hundreds of postings. Use maxJobs to limit results and recent to filter by date.
Exact Matching: Enable exactMatchingOnly: true for higher precision but potentially fewer results. Leave it disabled for broader coverage.

​
Error Handling

async function getJobsSafely(domain: string) {
   try {
      // Try to find career page
      const careerPage = await services.company.careers.findPage({ domain });

      if (!careerPage?.url) {
         console.log("No career page found");
         return [];
      }

      // Try to scrape jobs
      const jobs = await services.company.careers.scrapeJobs({
         url: careerPage.url,
         recent: "month",
      });

      return jobs;
   } catch (error) {
      console.error("Failed to get jobs:", error);
      return [];
   }
}

​
Integration Example

// Complete company intelligence workflow
async function getCompanyIntelligence(domain: string) {
   // Get company profile
   const companyUrl = await services.company.linkedin.findUrl({
      website: domain,
   });

   const company = await services.company.linkedin.enrich({
      url: companyUrl,
      enrichLevel: "extended",
   });

   // Get job postings
   const careerPage = await services.company.careers.findPage({ domain });
   const jobs = await services.company.careers.scrapeJobs({
      url: careerPage.url,
      recent: "month",
   });

   return {
      company: {
         name: company.company_name,
         size: company.employees_count,
         industry: company.industry,
      },
      hiring: {
         activeJobs: jobs.length,
         recentPostings: jobs,
         departments: jobs.reduce((acc, job) => {
            // Categorize jobs...
            return acc;
         }, {}),
      },
   };
}