Find LinkedIn profiles of Y Combinator companies’ employees

1
const airtop = new AirtopService({ apiKey, log });

1
this.client = new AirtopClient({ apiKey });

1
/**
2
   * Creates a new session.
3
   * @param profileName - The name of the profile to use for the session
4
   * @returns The created session
5
   */
6
  async createSession(profileName?: string): Promise<SessionResponse> {
7
    const session = await this.client.sessions.create({
8
      configuration: {
9
        timeoutMinutes: 15, // Terminate the session after 15 mins of inactivity
10
        profileName,
11
      },
12
    });
13
14
    this.savedSessions.set(session.data.id, session);
15
16
    return session;
17
  }

1
/**
2
   * Creates a new window.
3
   * @param sessionId - The ID of the session to create the window in
4
   * @param url - The URL to navigate to
5
   * @returns The created window
6
   */
7
  async createWindow(sessionId: string, url: string): Promise<WindowIdResponse> {
8
    const window = await this.client.windows.create(sessionId, { url });
9
10
    this.savedWindows.set(window.data.windowId, { sessionId, windowId: window.data.windowId });
11
12
    return window;
13
  }

1
/**
2
   * Gets the Y Combinator batches from the Y Combinator Company Directory page.
3
   * @returns {Promise<string[]>} A promise that resolves to an array of batches
4
   */
5
  async getYcBatches(sessionId?: string): Promise<string[]> {
6
    this.log.info("Initiating fetch to get YC batches");
7
8
    // Get session info if provided, otherwise create a new session
9
    const session = sessionId
10
      ? await this.airtop.client.sessions.getInfo(sessionId)
11
      : await this.airtop.createSession();
12
13
    // YC Company Directory window
14
    const window = await this.airtop.client.windows.create(session.data.id, {
15
      url: YC_COMPANIES_URL,
16
    });
17
18
    this.log.info("Extracting YC batches");
19
    // Extract the batches from the YC Company Directory page
20
    const modelResponse = await this.airtop.client.windows.pageQuery(session.data.id, window.data.windowId, {
21
      prompt: GET_YC_BATCHES_PROMPT,
22
      configuration: {
23
        outputSchema: GET_YC_BATCHES_OUTPUT_SCHEMA,
24
      },
25
    });
26
27
    if (!modelResponse.data.modelResponse || modelResponse.data.modelResponse === "") {
28
      throw new Error("No batches found");
29
    }
30
31
    const response = JSON.parse(modelResponse.data.modelResponse) as GetYcBatchesResponse;
32
33
    if (response.error) {
34
      throw new Error(response.error);
35
    }
36
37
    this.log
38
      .withMetadata({
39
        batches: response.batches,
40
      })
41
      .info("Successfully fetched YC batches");
42
43
    return response.batches;
44
  }

1
/**
2
* Prompt to get the list of batches from the Y Combinator Companies page
3
*/
4
export const GET_YC_BATCHES_PROMPT = `
5
You are looking at a startup directory page from Y Combinator. The startups are organized based on industry, region, company size, batch, and others.
6
Your task is to extract the list of batches from the page.
7
Batches follow the format: [Season][Year] where:
8
- Season is F (Fall), S (Spring), or W (Winter)
9
- Year is a 2-digit number (e.g., 24, 23, 22)
10
Examples: F24, S24, W24
11
12
Only include batches that appear in the dedicated batch filter/selection section of the page.
13
Return an empty array if no valid batches are found.`;
14
15
const GET_YC_BATCHES_SCHEMA = baseSchema.extend({
16
  batches: z.array(z.string()),
17
});
18
19
export type GetYcBatchesResponse = z.infer<typeof GET_YC_BATCHES_SCHEMA>;
20
21
export const GET_YC_BATCHES_OUTPUT_SCHEMA = zodToJsonSchema(GET_YC_BATCHES_SCHEMA);

1
/**
2
* Prompt to get the list of companies from the Y Combinator Companies page
3
*/
4
export const GET_COMPANIES_IN_BATCH_PROMPT = `
5
You are looking at a startup directory page from Y Combinator that has been filtered by batch. 
6
Your task is to extract information for the companies listed on the page.
7
8
For each company, extract:
9
1. Name (required): The company name exactly as shown (e.g., "Airtop")
10
2. Location (optional): The full location if provided (e.g., "San Francisco, CA")
11
3. Link (required): The full Y Combinator company URL (e.g., "https://ycombinator.com/companies/airtop")
12
13
Important:
14
- Only extract companies that have both a name and a valid YC link
15
- Return an empty array if no valid companies are found
16
`;
17
18
const GET_COMPANIES_IN_BATCH_SCHEMA = baseSchema.extend({
19
  companies: z.array(
20
    z.object({
21
      name: z.string(),
22
      location: z.string().optional(),
23
      link: z.string(),
24
    }),
25
  ),
26
});
27
28
export const GET_COMPANIES_IN_BATCH_OUTPUT_SCHEMA = zodToJsonSchema(GET_COMPANIES_IN_BATCH_SCHEMA);
29
export type Company = z.infer<typeof GET_COMPANIES_IN_BATCH_SCHEMA>["companies"][number];
30
export type GetCompaniesInBatchResponse = z.infer<typeof GET_COMPANIES_IN_BATCH_SCHEMA>;
31
32
33
/**
34
   * Gets the companies in a given Y Combinator batch.
35
   * @param {string} batch - The batch to get companies for
36
   * @param {string} sessionId - The ID of the session
37
   * @returns {Promise<string[]>} A promise that resolves to an array of company names
38
   */
39
  async getCompaniesInBatch(batch: string, sessionId?: string): Promise<Company[]> {
40
    this.log.info(`Initiating fetch to get companies in Y Combinator batch "${batch}"`);
41
42
    const session = sessionId
43
      ? await this.airtop.client.sessions.getInfo(sessionId)
44
      : await this.airtop.createSession();
45
46
    // YC Company Directory window
47
    const window = await this.airtop.client.windows.create(session.data.id, {
48
      url: `${YC_COMPANIES_URL}?batch=${batch}`,
49
    });
50
51
    this.log.info(`Extracting companies in batch "${batch}"`);
52
    const modelResponse = await this.airtop.client.windows.pageQuery(session.data.id, window.data.windowId, {
53
      prompt: GET_COMPANIES_IN_BATCH_PROMPT,
54
      configuration: {
55
        outputSchema: GET_COMPANIES_IN_BATCH_OUTPUT_SCHEMA,
56
      },
57
    });
58
59
    if (!modelResponse.data.modelResponse || modelResponse.data.modelResponse === "") {
60
      throw new Error("No companies found");
61
    }
62
63
    const response = JSON.parse(modelResponse.data.modelResponse) as GetCompaniesInBatchResponse;
64
65
    if (response.error) {
66
      throw new Error(response.error);
67
    }
68
69
    this.log
70
      .withMetadata({
71
        companies: response.companies,
72
      })
73
      .info("Successfully fetched companies in batch");
74
75
    return response.companies;
76
  }

1
 /**
2
   * Gets the LinkedIn profile URLs for a list of companies.
3
   * @param {Company[]} companies - The companies to get LinkedIn profile URLs for
4
   * @returns {Promise<string[]>} A promise that resolves to an array of LinkedIn profile URLs
5
   */
6
  async getCompaniesLinkedInProfileUrls(companies: Company[]): Promise<BatchOperationUrl[]> {
7
    const companyUrls: BatchOperationUrl[] = companies.map((c) => ({ url: c.link }));
8
9
    const getProfileUrl = async (input: BatchOperationInput): Promise<BatchOperationResponse<BatchOperationUrl>> => {
10
      this.log.info(`Scraping for LinkedIn profile URL ${input.operationUrl.url}`);
11
      const modelResponse = await this.airtop.client.windows.pageQuery(input.sessionId, input.windowId, {
12
        prompt: GET_COMPANY_LINKEDIN_PROFILE_URL_PROMPT,
13
        configuration: {
14
          outputSchema: GET_COMPANY_LINKEDIN_PROFILE_URL_OUTPUT_SCHEMA,
15
        },
16
      });
17
18
      if (!modelResponse.data.modelResponse || modelResponse.data.modelResponse === "") {
19
        throw new Error("No LinkedIn profile URL found");
20
      }
21
22
      const response = JSON.parse(modelResponse.data.modelResponse) as GetCompanyLinkedInProfileUrlResponse;
23
24
      if (response.error) {
25
        throw new Error(response.error);
26
      }
27
28
      if (!response.linkedInProfileUrl) {
29
        throw new Error("Failed to parse LinkedIn profile URL");
30
      }
31
32
      return {
33
        data: { url: response.linkedInProfileUrl },
34
      };
35
    };
36
37
    const handleError = async ({ error, operationUrls }: BatchOperationError) => {
38
      this.log.withError(error).withMetadata({ operationUrls }).error("Error extracting LinkedIn profile URL");
39
    };
40
41
    this.log.info("Getting LinkedIn profile URLs for companies");
42
    const profileUrls = await this.airtop.client.batchOperate(companyUrls, getProfileUrl, { onError: handleError });
43
44
    this.log
45
      .withMetadata({
46
        linkedInProfileUrls: companyUrls,
47
      })
48
      .info("Successfully fetched LinkedIn profile urls for the companies");
49
50
    return profileUrls.filter((url) => url.url !== null);
51
  }

1
/**
2
   * Checks if the user is signed into LinkedIn
3
   * @param sessionId - The ID of the session
4
   * @returns Whether the user is signed into LinkedIn
5
   */
6
  async checkIfSignedIntoLinkedIn(sessionId: string): Promise<boolean> {
7
    this.log.info("Checking if user is signed into LinkedIn");
8
    const window = await this.airtop.createWindow(sessionId, LINKEDIN_FEED_URL);
9
10
    const modelResponse = await this.airtop.client.windows.pageQuery(sessionId, window.data.windowId, {
11
      prompt: IS_LOGGED_IN_PROMPT,
12
      configuration: {
13
        outputSchema: IS_LOGGED_IN_OUTPUT_SCHEMA,
14
      },
15
    });
16
17
    if (!modelResponse.data.modelResponse || modelResponse.data.modelResponse === "") {
18
      throw new Error("No response from LinkedIn");
19
    }
20
21
    const response = JSON.parse(modelResponse.data.modelResponse) as IsLoggedInResponse;
22
23
    return response.isLoggedIn;
24
  }
25
26
27
  /**
28
   * Gets the LinkedIn login page Live View URL
29
   * @param sessionId - The ID of the session
30
   * @returns The LinkedIn login page Live View URL
31
   */
32
  async getLinkedInLoginPageLiveViewUrl(sessionId: string): Promise<string> {
33
    const linkedInWindow = await this.airtop.createWindow(sessionId, LINKEDIN_FEED_URL);
34
35
    const windowInfo = await this.airtop.client.windows.getWindowInfo(sessionId, linkedInWindow.data.windowId);
36
37
    return windowInfo.data.liveViewUrl;
38
  }

1
/**
2
* Extracts the LinkedIn employees search URL from the given text
3
* @param text - The text to extract the LinkedIn employees search URL from
4
* @returns The LinkedIn employees search URL or null if not found
5
*/
6
const extractEmployeeListUrl = (text: string): string | null => {
7
  // Pattern to match LinkedIn employees search URLs
8
  const pattern = /https:\/\/www\.linkedin\.com\/search\/results\/people\/\?[^"\s]*/g;
9
10
  // Find all search URLs
11
  const matches = text.match(pattern);
12
13
  // Filter to only include URLs with currentCompany parameter
14
  const employeesUrl = matches?.find((url) => url.includes('currentCompany='));
15
16
  return employeesUrl || null;
17
};
18
19
20
  /**
21
   * Gets the LinkedIn employees list URLs for a given set of companies
22
   * @param companyLinkedInProfileUrls - The list of company LinkedIn profile URLs
23
   * @param sessionId - The ID of the session
24
   * @returns The list of LinkedIn employees list URLs
25
   */
26
  async getEmployeesListUrls({
27
    companyLinkedInProfileUrls,
28
    profileName,
29
  }: {
30
    companyLinkedInProfileUrls: BatchOperationUrl[];
31
    profileName: string;
32
  }): Promise<BatchOperationUrl[]> {
33
    this.log.info("Attempting to get the list of employees for the companies");
34
35
    const getEmployeesListUrl = async (input: BatchOperationInput): Promise<BatchOperationResponse<string>> => {
36
      const scrapedContent = await this.airtop.client.windows.scrapeContent(input.sessionId, input.windowId);
37
38
      const url = this.extractEmployeeListUrl(scrapedContent.data.modelResponse.scrapedContent.text);
39
40
      if (!url) {
41
        throw new Error("No employees list URL found");
42
      }
43
44
      return {
45
        data: url,
46
      };
47
    };
48
49
    const handleError = async ({ error, operationUrls, liveViewUrl }: BatchOperationError) => {
50
      this.log
51
        .withError(error)
52
        .withMetadata({
53
          liveViewUrl,
54
          operationUrls,
55
        })
56
        .error("Error extracting employees list URL for company LinkedIn profile.");
57
    };
58
59
    const employeesListUrls = await this.airtop.client.batchOperate(companyLinkedInProfileUrls, getEmployeesListUrl, {
60
      onError: handleError,
61
      sessionConfig: {
62
        profileName, // Profile logged into LinkedIn
63
      },
64
    });
65
66
    this.log
67
      .withMetadata({
68
        employeesListUrls,
69
      })
70
      .info("Successfully fetched employee list URLs for the companies");
71
72
    // Filter out any null values and remove duplicates
73
    return [...new Set(employeesListUrls.filter((url) => url !== null).map((url) => ({ url })))];
74
  }

1
/**
2
   * Gets the LinkedIn employees profile URLs for a list of LinkedIn employees list URLs
3
   * @param employeesListUrls - The list of LinkedIn employees list URLs
4
   * @param sessionId - The ID of the session
5
   * @returns The list of LinkedIn employees profile URLs
6
   */
7
  async getEmployeesProfileUrls({
8
    employeesListUrls,
9
    profileName,
10
  }: { employeesListUrls: BatchOperationUrl[]; profileName: string }): Promise<string[]> {
11
    this.log.info("Initiating extraction of employee's profile URLs for the employees");
12
13
    const getEmployeeProfileUrl = async (input: BatchOperationInput): Promise<BatchOperationResponse<string[]>> => {
14
      this.log.info(`Scraping content for employee URL: ${input.operationUrl.url}`);
15
      const scrapedContent = await this.airtop.client.windows.scrapeContent(input.sessionId, input.windowId);
16
17
      const newUrls = this.extractEmployeeProfileUrls(scrapedContent.data.modelResponse.scrapedContent.text);
18
19
      return {
20
        data: newUrls,
21
      };
22
    };
23
24
    const employeesProfileUrls = (
25
      await this.airtop.client.batchOperate(employeesListUrls, getEmployeeProfileUrl, {
26
        sessionConfig: {
27
          profileName, // Profile logged into LinkedIn
28
        },
29
      })
30
    ).flat();
31
32
    this.log
33
      .withMetadata({
34
        employeesProfileUrls,
35
      })
36
      .info("Successfully obtained employee profile URLs");
37
38
    return employeesProfileUrls;
39
  }

1
/**
2
   * Terminates a session.
3
   * @param sessionId - The ID of the session to terminate
4
   */
5
  async terminateSession(sessionId: string | undefined): Promise<void> {
6
    if (!sessionId) {
7
      return;
8
    }
9
10
    this.log.debug(`Terminating session: ${sessionId}`);
11
12
    // Terminate the session
13
    await this.client.sessions.terminate(sessionId);
14
  }