# Specify the base Docker image. You can read more about
# the available images at https://sdk.apify.com/docs/guides/docker-images
# You can also use any other image from Docker Hub.
FROM apify/actor-node:16 AS builder

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY package*.json ./

COPY .npmrc ./


# Install all dependencies. Don't audit to speed up the installation.
RUN npm install --include=dev --audit=false

# Next, copy the source files using the user set
# in the base image.
COPY . ./

# Install all dependencies and build the project.
# Don't audit to speed up the installation.
RUN npm run build

# Create final image
FROM apify/actor-node:16

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY package*.json ./

COPY .npmrc ./

# Install NPM packages, skip optional and development dependencies to
# keep the image small. Avoid logging too much and print the dependency
# tree for debugging
RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version \
    && rm -r ~/.npm

# Copy built JS files from builder image
COPY --from=builder /usr/src/app/dist ./dist

# Next, copy the remaining files and directories with the source code.
# Since we do this after NPM install, quick build will be really fast
# for most source file changes.
COPY . ./


# Run the image.
CMD npm run start:prod --silent


.actor/Dockerfile

linkedin-bulk-email-lookup

Linkedin email lookup

.actor/actor.json

Overview

.actor/dataset_schema.json

📧 Emails

Email linkedin grabber input

.actor/input_schema.json

import { Directus } from "@directus/sdk";
import { User } from "src/types/user";

export type MyDirectus = Directus<{ Account: User }>;

export class GetDirectus {
  private static instance: GetDirectus;
  private directus: MyDirectus;

  private constructor() {
    this.directus = new Directus(process.env.DIRECTUS_URL);
  }

  public static async getInstance(): Promise<MyDirectus> {
    if (!GetDirectus.instance) {
      GetDirectus.instance = new GetDirectus();
      await GetDirectus.instance.authenticate();
    }

    return GetDirectus.instance.getDirectus();
  }

  public getDirectus(): MyDirectus {
    return this.directus;
  }

  async authenticate() {
    return await this.directus.auth.login({
      email: process.env.DIRECTUS_EMAIL,
      password: process.env.DIRECTUS_PASSWORD,
    });
  }
}


src/core/directus.ts


import { getLogger } from '../logger'


export enum ErrorType {
  LINKEDIN_INVALID_TOKEN_FORMAT = 'LINKEDIN_INVALID_TOKEN_FORMAT',
  EXPIRED_TOKEN = 'EXPIRED_TOKEN',
  UNKNOWN_LINKEDIN_REQUEST_ERROR = 'UNKNOWN_LINKEDIN_REQUEST_ERROR',
  LINKEDIN_ACCOUNT_NOT_FOUND = 'LINKEDIN_ACCOUNT_NOT_FOUND',
  LINKEDIN_ACCOUNT_WITHOUT_DATA = 'LINKEDIN_ACCOUNT_WITHOUT_DATA',
  LINKEDIN_ACCOUNT_NOT_FETCHABLE = 'LINKEDIN_ACCOUNT_NOT_FETCHABLE',
  NO_MORE_TOKENS = 'NO_MORE_TOKENS',
  TOKEN_BANNED = 'TOKEN_BANNED',
}


export const LinkedinErrorType = {
  RpsTokenExpired: 'RpsTokenExpired',
  RpsTokenInvalidFormat: 'RpsTokenInvalidFormat',
  "65608": "65608",
  ConsumerResolutionWithoutValidIds: "ConsumerResolutionWithoutValidIds",
  UnknownForbiddenResponseFromMsGraphException: "UnknownForbiddenResponseFromMsGraphException",
} as const

const linkedinErrorToErrorType = {
  [LinkedinErrorType.RpsTokenExpired]: ErrorType.EXPIRED_TOKEN,
  [LinkedinErrorType.RpsTokenInvalidFormat]: ErrorType.LINKEDIN_INVALID_TOKEN_FORMAT,
  [LinkedinErrorType[65608]]: ErrorType.TOKEN_BANNED,
  [LinkedinErrorType.ConsumerResolutionWithoutValidIds]: ErrorType.LINKEDIN_ACCOUNT_NOT_FETCHABLE,
  [LinkedinErrorType.UnknownForbiddenResponseFromMsGraphException]: ErrorType.TOKEN_BANNED,
}


export class BaseError extends Error {

  _isBaseError = true

  _errorType: ErrorType;

  _linkedinErrorType?: keyof typeof LinkedinErrorType;

  _linkedinErrorDetails?: Record<string, any>;

  static log = getLogger(BaseError.name)
  
  constructor(
    type: ErrorType,
    opt?: {
      linkedinErrorType?: keyof typeof LinkedinErrorType;
      message?: string;
      linkedinErrorDetails?: Record<string, any>;
    }
  ) {
    super(`${type} : ${opt?.message || "N/A"}`)
    // BaseError.log.error(`${type} : ${opt?.message || "N/A"}`)
    this._errorType = type;
    this._linkedinErrorType = opt?.linkedinErrorType
    this._linkedinErrorDetails = opt?.linkedinErrorDetails
  }

  static fromLinkedinRequestError(error: any) {
    if (error?.hasOwnProperty('_isBaseError')) return error;
    const linkedinErrorDetails = error?.response?.data
    // console.log('LINKEDIN ERROR', error?.response?.data)
    const errorCode = error?.response?.data?.Error?.Code
    // console.log("CODE", errorCode)
    const message = error?.response?.data?.Error?.Message.Message
    if (!errorCode) {
      BaseError.log.debug(`Can\' detect linkedin error code`)
      return new BaseError(ErrorType.UNKNOWN_LINKEDIN_REQUEST_ERROR, {
        linkedinErrorDetails,
        message
      })
    }
    const type = linkedinErrorToErrorType[errorCode]
    // console.log("TYPE", type)

    if (!type) {
      BaseError.log.debug(`Not error type for linkedin error: ${errorCode}`)
      return new BaseError(ErrorType.UNKNOWN_LINKEDIN_REQUEST_ERROR, {
        linkedinErrorDetails,
        linkedinErrorType: errorCode,
        message
      })
    }
    return new BaseError(type, {
      linkedinErrorDetails,
      linkedinErrorType: errorCode,
      message
    })
  }
}

src/errors/base.error.ts

src/mockups/emails.ts

export interface Locale {
    country: string;
    language: string;
}

export interface School {
    schoolName: string;
    schoolLocation: string;
    schoolLogo: string;
    linkedInUrl: string;
}

export interface Start {
    month: number;
    year: number;
}

export interface End {
    month: number;
    year: number;
}

export interface StartEndDate {
    start: Start;
    end: End;
}

export interface EducationHistory {
    school: School;
    degreeName: string;
    startEndDate: StartEndDate;
    fieldOfStudy: string;
    schoolName: string;
    schoolLocation: string;
    schoolLogo: string;
    linkedInUrl: string;
}

export interface Schools {
    educationsCount: number;
    educationHistory: EducationHistory[];
}

export interface Start2 {
    month: number;
    year: number;
}

export interface End2 {
    month?: number;
    year?: number;
}

export interface StartEndDate2 {
    start: Start2;
    end: End2;
}

export interface Company {
    companyName: string;
    linkedInUrl: string;
    companyLocation: string;
    companyLogo: string;
}

export interface PositionHistory {
    title: string;
    startEndDate: StartEndDate2;
    company: Company;
    companyName: string;
    linkedInUrl: string;
    companyLocation: string;
    companyLogo: string;
}

export interface Positions {
    positionsCount: number;
    positionHistory: PositionHistory[];
}

export interface SkillEndorsements {
    skillEndorsementsCount: number;
    skillEndorsements: any[];
}

export interface NewsMentions {
    newsMentionCount: number;
    newsMentions: any[];
}

export interface UserGeneratedContents {
    userGeneratedContentCount: number;
    userGeneratedContents: any[];
}

export interface Person {
    id: string;
    displayName: string;
    firstName: string;
    lastName: string;
    emails: any[];
    phoneNumbers: any[];
    headline: string;
    companyName: string;
    location: string;
    photoUrl: string;
    linkedInUrl: string;
    reportProfileUrl: string;
    connectionDegree: string;
    connectionStatus: string;
    locale: Locale;
    schools: Schools;
    positions: Positions;
    skillEndorsements: SkillEndorsements;
    newsMentions: NewsMentions;
    userGeneratedContents: UserGeneratedContents;
    isPublic: boolean;
}

export interface RootObject {
    persons: Person[];
}



src/types/Profile.ts

export type InitInput = {
    cookie: string,
}

src/types/dto.ts

export interface User {
    id: string;
    avatar: string;
    firstName: string;
    lastName: string;
    email: string;
    profileUrl?: string;
    password: string;
    birthDate: Date;
    isLinkedInAccountCreated?: boolean;
    isAvatarSetUp?: boolean;
    profileStorage?: any; // IUserProfile
    linkedInCreated?: boolean;
    lokiAuthToken?: string;
    li_al: string;
    date_created: string;
    date_updated: string;
    is_banned: boolean;
  }

  export type LightAccount = Pick<User, 'id' | 'lokiAuthToken' | 'date_created' | 'date_updated' | `linkedInCreated` | 'is_banned'>;

src/types/user.ts

import { BaseError } from "./errors/base.error";
import * as fs from 'fs';
import { getLogger } from "./logger";
import { LightAccount } from "./types/user";
import * as _ from 'lodash'
import { AccountDto, AccountManager, AccountModel, LinkedinStatusEnum } from "@bebity/scraping-account-manager.git";

export type Email = { email: string, control: boolean }


export class EmailProvider {
  static index = -1;

  protected db: Email[] = [];

  constructor(emails: string[], controls: string[]) {
    const interval = Math.ceil(emails.length / controls.length);
    this.mergeEmailsWithControls(emails, controls, interval);
  }

  static increment() {
    EmailProvider.index += 1;
  }

  static decrement() {
    EmailProvider.index -= 1;
  }
  
  private mergeEmailsWithControls(emails: string[], controls: string[], interval: number): void {
    let controlIndex = 0;
    for (let i = 0; i < emails.length; i++) {
      this.db.push({ email: emails[i], control: false });
      if ((i + 1) % interval === 0 && controlIndex < controls.length) {
        this.db.push({ email: controls[controlIndex], control: true });
        controlIndex++;
      }
    }
  }

  public syncGet(): Email | null {
    if (EmailProvider.index >= this.db.length) return null;
    if (EmailProvider.index < 0) return null;
    return this.db[EmailProvider.index] || null;
  }

  public syncGetNext(): Email | null {
    EmailProvider.increment();
    return this.syncGet();
  }

  public syncGetPrev(): Email | null {
    EmailProvider.decrement();
    return this.syncGet();
  }

  public async get(): Promise<Email | null> {
    return this.syncGet();
  }

  public async getNext(): Promise<Email | null> {
    return this.syncGetNext();
  }

  public async getPrev(): Promise<Email | null> {
    return this.syncGetPrev();
  }
}


export class TokenProvider {

  actual: AccountModel | null = null;

  client = new AccountManager({
    directus: {
      directusUrl: 'https://account-manager.cariz.fr',
      directusToken: 'a7u56kr2zkuvgSunoCP9Qr38xY8j0_sN'
    }
  })

  constructor() {}

  public syncGet(): AccountDto | null {
    return this.actual?.toDto() || null;
  }

  public async get(): Promise<AccountDto | null> {
    return this.syncGet();
  }

  async freeActual(newStatus: LinkedinStatusEnum = LinkedinStatusEnum.READY) {
    if (this.actual) {
      await this.actual.updateLinkedinStatus(newStatus);
      this.actual = null;
    }
  }

  public async getNext(newStatus?: LinkedinStatusEnum): Promise<AccountDto | null> {
    await this.freeActual(newStatus);
    const tmp = await this.client.account.getNext({
      linkedin: { status: { _eq: LinkedinStatusEnum.READY }}
    });
    if (tmp && !tmp.isLinkedinReady) {
      await tmp.updateLinkedinStatus(LinkedinStatusEnum.BAD_TOKEN);
      return await this.getNext();
    }
    this.actual = tmp || null;
    await this.actual?.useLinkedin();
    return this.get();
  }
}



export class ExecContext {

  public successEmails: { [k: string]: string[] } = {}

  public successControls: { [k: string]: string[] } = {}

  public failedEmails:  { [k: string]: { email: string, error: BaseError }[] } = {}

  public failedControls: { [k: string]: { email: string, error: BaseError }[] } = {}

  constructor(
    public emails: EmailProvider,
    public tokens: TokenProvider,
    private logFile: boolean = false,
  ) {}

  addSuccessEmail(email: string, control: boolean) {
    if (this.logFile) { this.createTokenLoggerDir(); }
    if (control) {
      if (!this.successControls[this.tokens.syncGet()?.id]) {
        this.successControls[this.tokens.syncGet()?.id] = [];
      }
      this.successControls[this.tokens.syncGet()?.id].push(email);
    } else {
      if (!this.successEmails[this.tokens.syncGet()?.id]) {
        this.successEmails[this.tokens.syncGet()?.id] = [];
      }
      this.successEmails[this.tokens.syncGet()?.id].push(email);
    }
    if (this.logFile) {
      this.successLog(email, control);
      this.successLog(email, control, true);
      this.mainLog();
      this.mainLogByToken();
    }
  }

  addFailedEmail(email: string, control: boolean, error: BaseError) {
    this.createTokenLoggerDir();
    if (control) {
      if (!this.failedControls[this.tokens.syncGet()?.id]) {
        this.failedControls[this.tokens.syncGet()?.id] = [];
      }
      this.failedControls[this.tokens.syncGet()?.id].push({ email, error });
    } else {
      if (!this.failedEmails[this.tokens.syncGet()?.id]) {
        this.failedEmails[this.tokens.syncGet()?.id] = [];
      }
      this.failedEmails[this.tokens.syncGet()?.id].push({ email, error });
    }
    this.errorLog(email, control, error);
    this.errorLog(email, control, error, true);
    this.mainLog();
    this.mainLogByToken();
  }

  init() {
    this.createLoggerDir();
  }

  createLoggerDir() {
    if (!fs.existsSync('logs')) {
      fs.mkdirSync('logs', { recursive: true });
    }
  }

  createTokenLoggerDir() {
    if (!fs.existsSync(`logs/${this.tokens.syncGet()?.id}`)) {
      fs.mkdirSync(`logs/${this.tokens.syncGet()?.id}`, { recursive: true });
    }
  }

  mainLog() {
    const allFailedEmails = Object.keys(this.failedEmails).map((el) => this.failedEmails[el]).flat()
    const allFailedControlEmails = Object.keys(this.failedControls).map((el) => this.failedControls[el]).flat()

    const groupedErrors = _.groupBy(allFailedEmails, 'error._errorType')
    const groupedControlErrors = _.groupBy(allFailedControlEmails, 'error._errorType')

    const log = `
current email: [control: ${this.emails.syncGet()?.control}] => ${this.emails.syncGet()?.email}
success: ${Object.keys(this.successEmails).reduce((acc, el) => acc + this.successEmails[el]?.length, 0)}
errors: ${Object.keys(this.failedEmails).reduce((acc, el) => acc + this.failedEmails[el]?.length, 0)}
last error: ${ JSON.stringify(this.failedEmails[this.tokens.syncGet()?.id]?.[this.failedEmails[this.tokens.syncGet()?.id]?.length - 1])}
current token: ${this.tokens.syncGet()?.id}
all errors:
  - ${Object.keys(groupedErrors).map((el) => `${el} => ${groupedErrors[el].slice(0, 100).map((data) => data.email).join(', ')}`).join('\n  - ')}

control success: ${Object.keys(this.successControls).reduce((acc, el) => acc + this.successControls[el]?.length, 0)}

control faileds:
  - ${Object.keys(groupedControlErrors).map((el) => `${el} => ${groupedControlErrors[el]?.slice(0, 100).map((data) => data.email).join(', ')}`).join('\n  - ')}
`

    fs.writeFileSync(`logs/log.txt`, log);
  }

  mainLogByToken() {
    const token = this.tokens.syncGet()?.id
    const groupedErrors = _.groupBy(this.failedEmails[token], 'error._errorType')
    const groupedControlErrors = _.groupBy(this.failedControls[token], 'error._errorType')

    const log = `
current email: [control: ${this.emails.syncGet()?.control}] => ${this.emails.syncGet()?.email}
success: ${this.successEmails[token]?.length}
errors: ${this.failedEmails[token]?.length}
last error: ${ JSON.stringify(this.failedEmails[token]?.[this.failedEmails[token]?.length - 1])}
current token: ${token}
all errors:
  - ${Object.keys(groupedErrors).map((el) => `${el} => ${groupedErrors[el]?.slice(0, 100).map((data) => data.email).join(', ')}`).join('\n    - ')}

control success: ${this.successControls[token]?.reduce((acc, el) => acc + this.successControls[el]?.length, 0)}

control faileds:
  - ${Object.keys(groupedControlErrors).map((el) => `${el} => ${groupedControlErrors[el]?.slice(0, 100).map((data) => data.email).join(', ')}`).join('\n    - ')}
`

    fs.writeFileSync(`logs/${token}/log.txt`, log);
  }

  successLog(email: string, control: boolean, forCurrentToken: boolean = false) {
    const log = [
      new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' }),
      email,
    ]
    if (forCurrentToken) fs.appendFileSync(`logs/success.txt`, log.join('|') + '\n');
    else fs.appendFileSync(`logs/${this.tokens.syncGet()?.id}/success.txt`, log.join('|') + '\n');
  }

  errorLog(email: string, control: boolean, err: BaseError, forCurrentToken: boolean = false) {
    const log = [
      new Date().toLocaleDateString('en-US', { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' }),
      err._errorType,
      email,
      err.message,
      err._linkedinErrorType,
      err._linkedinErrorDetails ? JSON.stringify(err._linkedinErrorDetails || {}) : null
    ]
    if (forCurrentToken) fs.appendFileSync(`logs/errors.txt`, log.join('|') + '\n');
    else fs.appendFileSync(`logs/${this.tokens.syncGet()?.id}/errors.txt`, log.join('|') + '\n');
  }
}

src/context.ts

import axios, { AxiosResponse } from "axios";
import { InitInput } from "./types/dto";
import { BaseError, ErrorType } from "./errors/base.error";
import { getLogger } from "./logger";
import { Email } from "./context";
import { LinkedinStatusEnum } from "@bebity/scraping-account-manager.git";

export class Linkedin {

  checkAccountData = (data: Record<string, any>) => {
    const check = data.hasOwnProperty("displayName")
    if (!check) throw new BaseError(ErrorType.LINKEDIN_ACCOUNT_WITHOUT_DATA)
    return data
  };


  getInfo = async (
    email: string,
    token: string
  ): Promise<Record<string, any>> => {
    try {
      const baseURL =
        "https://eur.loki.delve.office.com/api/v2/linkedin/profiles?&UserLocale=fr-FR&Smtp=" +
        email +
        "&PersonaType=User&";
      const headers = {
        Accept: "text/plain, application/json, text/json",
        "X-ClientType": "OwaPeopleHub",
        "X-ClientFeature": "LivePersonaCard",
        "X-ClientArchitectureVersion": "v1",
        "X-ClientScenario": "PeopleHubEmbeddedEV",
        "X-HostAppPlatform": "Web",
        "X-LPCVersion": "1.20230218.2.5",
        authorization: "Bearer " + token,
        "X-HostAppCapabilities": '{"isLokiContactDataDisabled":false}',
      };

      const rslt = await axios.get(baseURL, { headers });
      if (!rslt?.data?.persons?.[0])
        throw new BaseError(ErrorType.LINKEDIN_ACCOUNT_NOT_FOUND);
      return this.checkAccountData(rslt.data.persons[0]);
    } catch (err) {
      throw BaseError.fromLinkedinRequestError(err);
    }
  };
}

export class LinkedinWrapper {
  log = getLogger(LinkedinWrapper.name);

  constructor(
    protected actions: {
      getNextEmail: (
        retry?: true
      ) => Promise<Email | null>;
      rotateToken: (updateOldToken?: {
        status: LinkedinStatusEnum;
      }) => Promise<string | null>;
      saveResponse: (email: string, data: Record<string, any>) => Promise<void>;
      makePause: () => Promise<void>;
      onError?: (email: Email, err: BaseError) => Promise<void>;
      onStart?: (email: Email) => Promise<void>;
      onSuccess?: (email: Email, data: Record<string, any>) => Promise<void>;
      onControlFail?: (email: Email, err: BaseError) => Promise<void>;
      onControlSuccess?: (email: Email) => Promise<void>;
    }
  ) {}

  async exec() {
    const {
      rotateToken,
      getNextEmail,
      saveResponse,
      onError,
      makePause,
      onStart,
      onSuccess,
      onControlFail,
      onControlSuccess,
    } = this.actions;

    const scraper = new Linkedin();
    let token = await rotateToken();

    let emailElement = await getNextEmail();

    const errorToAction = {
      [ErrorType.EXPIRED_TOKEN]: {
        fn: async () => {
          token = await rotateToken({ status: LinkedinStatusEnum.TOKEN_EXPIRED });
        },
        retry: true,
      },
      [ErrorType.LINKEDIN_INVALID_TOKEN_FORMAT]: {
        fn: async () => {
          token = await rotateToken({ status: LinkedinStatusEnum.BAD_TOKEN });
        },
        retry: true,
      },
      [ErrorType.TOKEN_BANNED]: {
        fn: async () => {
          token = await rotateToken({ status: LinkedinStatusEnum.BANNED });
        },
        retry: true,
      },
      [ErrorType.LINKEDIN_ACCOUNT_WITHOUT_DATA]: {
        fn: async () => {
          token = await rotateToken({ status: LinkedinStatusEnum.SHADOW_BAN });
        },
        retry: true,
      },
    };

    let retryEmail = undefined;
    while (emailElement) {
      const { email, control } = emailElement;
      if (!token) throw new BaseError(ErrorType.NO_MORE_TOKENS);
      try {
        await onStart?.(emailElement);
        const rslt = await scraper.getInfo(email, token);
        if (control) await onControlSuccess(emailElement);
        else {
          await saveResponse(email, rslt);
          await onSuccess?.(emailElement, rslt);
        }
        retryEmail = undefined;
      } catch (err) {
        const error = err as BaseError;
        if (control) await onControlFail(emailElement, error);
        const action = errorToAction[error._errorType];
        retryEmail = action?.retry;
        await action?.fn?.();
        await onError?.(emailElement, error);
      }
      await makePause();
      emailElement = await getNextEmail(retryEmail);
    }
  }
}


src/linkedin.ts

import { Logger, ILogObj } from 'tslog';

export type LoggerType = Logger<ILogObj>;

export const getLogger = (prefix: string): Logger<ILogObj> => new Logger({
  prettyLogTemplate: '{{hh}}:{{MM}}:{{ss}} {{logLevelName}}\t[{{fileNameWithLine}}{{name}}]\t',
  stylePrettyLogs: true,
  minLevel: 0,

  prefix: [prefix],
});

export function testLog() {
  const logger = getLogger('test');
  logger.silly('Silly log');
  logger.debug('Debug log');
  logger.error('Error log');
  logger.fatal('Fatal log');
  logger.info('Info log');
  logger.trace('Trace log');
  logger.warn('Warn log');
}

src/logger.ts

import { Actor } from "apify";
import { LinkedinWrapper } from "./linkedin";
import { GetDirectus } from "./core/directus";
import { Logger } from "tslog";
// import { testEmail5000, testEmail600, workingMails } from "./mockups/emails";
import { getLogger, testLog } from "./logger";
import * as _ from 'lodash'
import { BaseError } from "./errors/base.error";
import { EmailProvider, TokenProvider, ExecContext, Email } from "./context";
import { workingMails } from "./mockups/emails";


(async () => {
  testLog()
  await Actor.init();
  const log = new Logger();

  const input = (await Actor.getInput()) as { emails: string[] };

  // const directus = await GetDirectus.getInstance();

  // const Authtoken = await directus.items("Account").readByQuery({
  //   filter: {
  //     isBanned: false,
  //     isLinkedInAccountCreated: true,
  //   },
  //   sort: ["-date_updated"],
  //   limit: 20,
  // });

  const emailProvider = new EmailProvider(input.emails, workingMails.slice(0, input.emails.length / 10));

  const tokenProvider = new TokenProvider();

  const context = new ExecContext(emailProvider, tokenProvider, true);

  const logger = getLogger('#### MAIN ####');
  
  const wrapper = new LinkedinWrapper({
    getNextEmail: async (retry?: true) => retry ? context.emails.syncGet() : emailProvider.syncGetNext(), 
    rotateToken: async (toUpdate) => (await context.tokens.getNext(toUpdate?.status))?.linkedin?.[0]?.loki_auth_token,
    saveResponse: async (email, data) => { await Actor.pushData({ ...data, email }) },
    makePause: () => new Promise((f) => setTimeout(f, 2000)),
    // onStart: async (email: Email) => { logger.info('START SCRAP', email) },
    onError: async (email, err) => {
      logger.error('### ERROR FOR :', email, err.message);
      context.addFailedEmail(email.email, email.control, err)
    },
    onSuccess: async (email) => {
      logger.debug('FOUND ACCOUNT FOR :', email)
      context.addSuccessEmail(email.email, email.control)
    },
    onControlSuccess: async (email: Email) => {
      logger.warn('CONTROL SUCCESS FOR :', email)
      context.addSuccessEmail(email.email, email.control)
    },
    onControlFail: async (email: Email, err: BaseError) => {
      logger.fatal('CONTROL FAIL FOR :', email, err.message)
      context.addFailedEmail(email.email, email.control, err)
    }
  });
  
  try {
    await wrapper.exec();
    await context.tokens.freeActual();
  } catch (err) {
    await context.tokens.freeActual();
    throw err;
  }
  await Actor.exit();
})();


src/main.ts

// This is the main Node.js source code file of your actor.
// An actor is a program that takes an input and produces an output.

// For more information, see https://sdk.apify.com/
import { Actor } from 'apify';

interface InputSchema {
    firstNumber: number;
    secondNumber: number;
}

// await Actor.init();

// console.log('Loading input');
// // Structure of input is defined in .actor/input_schema.json.
// const input = await Actor.getInput<InputSchema>();
// console.log('First number: ', input?.firstNumber);
// console.log('Second number: ', input?.secondNumber);


// Structure of output is defined in .actor/actor.json
// await Actor.pushData({
//     firstNumber: input?.firstNumber,
//     secondNumber: input?.secondNumber,
//     sum: result,
// });

// await Actor.exit();


src/main2.ts

import WebSocket from 'ws';
import { Actor, Dataset } from 'apify';
import { Person } from './types/Profile';
import pako from 'pako';


(async () => {
  await Actor.init();
  const output = []


  const ws = new WebSocket('wss://eur.loki.delve.office.com/stikkontakt.ws/?clientType=OwaPeopleHub/', {
    headers: {
      "Content-Type": "application/json-patch+json",
      "X-ClientType": "OwaPeopleHub",
      "X-ClientFeature": "LivePersonaCard",
      "X-ClientArchitectureVersion": "v1",
      "X-HostAppPlatform": "Web",
      "X-LPCVersion": "1.20230218.2.5",
      "authorization": "Bearer EwA4A92CBAAUf4ol7B29dDSCjZbDaiOfPJRcm/AAAfNJnb36YAapA9ddEgugCrnEwsajOQFDDEonTb8oc3tpLrgga/ebowe021/KH5VLFeiSrmNTGzMk9WFZRTfH8gWNdEGZDdFpn90oK/EVJQ14czcPgMeeHIuk72/mebxBOxiUOvtc6n4kG2qfs9958hOPs1xm+LQOB15kbLO7I2s3D+Ewh0Udm85T3ENq40BbOY+1NAKgNfoEUZ66TSjTOuW1NqI47yYpiWwCo0kUxhywBy+2p711sUgr5Nw606JHASs9hAp6/nHGEtF5yDOHxCZ4Mog/1WjDuSMnZNvxQYPTPXQCX0M/z4L54ySF1eu5dK4HvuQhnPGxCf0T1GzmeFwDZgAACKqTx0RDr9xyCAJqTPqUWjcUbym1TctR2h+xrWr284tR9ODUIFQjxgMfwrCopND0m9uFUdaDYKlsvaqwTlzAKsNULL70HxxcgMEI0WHn6oS4AiYfVxMTWBJt0dg3qRl0qr1QJkudYpBRZGh/P8zyUKaAAl+F6LUoAKLAn1abDp0dg7/mneIaBVrWrmGoVEl3Fuiq9Ci0gcx1WeWmHe94edh+ov6n6FQihluiEMiMEdzSelUCKbcrMsg/EG1r7V7SSybzXzPbTdIPg194DgJ7UFlX/JLPU/waL4iHKhldEZldU0iL5nf/XjGdnv+Kf4koosNXciLeyM2VnF6wbWum79LrEeABm+ox32uzHWt+UmJtCKg4kjm0Od5gcKtpiZ55yz39SNSUIu2dIuA88354OaDzSrkT3+gag1wHvCrql/dNyf66tq3GK8wm4V47FdEnZ2b+GgYlDEVWZspXI1HafrLrp4/svE+vwR9M8ozowoBRyxutAKwJ7CM3LpwvJjEOA86q9a1Xy1RQVpfY0qqfjK1dCbxEVcH6dglR8JrrFxvqMHc1RPIsPWCziUtVQnWmKo0PbogDGN9bRTMxOF+8tA5naSP8Shp2x9CBKcut/nac/nghNtFjzsGbra5pp/eCxyWZ+Xlhp+lAppw/hElAzkv/F4X1bsZ2F9R7LBo9tTvpQkHJM/3yZuLkofLORef5zbZeSQI=",
      "X-HostAppCapabilities": "{\"isLokiContactDataDisabled\":false}",
    }
  });


  const makeRequest = (email: string) => {
    try {
      ws.binaryType = "arraybuffer";
      console.log(ws.binaryType);

      const request = {
        "Key": "61",
        "Url": `https://eur.loki.delve.office.com/api/v2/linkedin/profiles?&UserLocale=fr-FR&Smtp=${email}&PersonaType=User&`,
        "Verb": "GET",
        "Headers": {
          "Accept": "text/plain, application/json, text/json",
          "X-ClientType": "OwaPeopleHub",
          "X-ClientFeature": "LivePersonaCard",
          "X-ClientArchitectureVersion": "v1",
          "X-ClientScenario": "PeopleHubEmbeddedEV",
          "X-HostAppPlatform": "Web",
          "X-LPCVersion": "1.20230218.2.5",
          "authorization": "Bearer EwA4A92CBAAUf4ol7B29dDSCjZbDaiOfPJRcm/AAAfNJnb36YAapA9ddEgugCrnEwsajOQFDDEonTb8oc3tpLrgga/ebowe021/KH5VLFeiSrmNTGzMk9WFZRTfH8gWNdEGZDdFpn90oK/EVJQ14czcPgMeeHIuk72/mebxBOxiUOvtc6n4kG2qfs9958hOPs1xm+LQOB15kbLO7I2s3D+Ewh0Udm85T3ENq40BbOY+1NAKgNfoEUZ66TSjTOuW1NqI47yYpiWwCo0kUxhywBy+2p711sUgr5Nw606JHASs9hAp6/nHGEtF5yDOHxCZ4Mog/1WjDuSMnZNvxQYPTPXQCX0M/z4L54ySF1eu5dK4HvuQhnPGxCf0T1GzmeFwDZgAACKqTx0RDr9xyCAJqTPqUWjcUbym1TctR2h+xrWr284tR9ODUIFQjxgMfwrCopND0m9uFUdaDYKlsvaqwTlzAKsNULL70HxxcgMEI0WHn6oS4AiYfVxMTWBJt0dg3qRl0qr1QJkudYpBRZGh/P8zyUKaAAl+F6LUoAKLAn1abDp0dg7/mneIaBVrWrmGoVEl3Fuiq9Ci0gcx1WeWmHe94edh+ov6n6FQihluiEMiMEdzSelUCKbcrMsg/EG1r7V7SSybzXzPbTdIPg194DgJ7UFlX/JLPU/waL4iHKhldEZldU0iL5nf/XjGdnv+Kf4koosNXciLeyM2VnF6wbWum79LrEeABm+ox32uzHWt+UmJtCKg4kjm0Od5gcKtpiZ55yz39SNSUIu2dIuA88354OaDzSrkT3+gag1wHvCrql/dNyf66tq3GK8wm4V47FdEnZ2b+GgYlDEVWZspXI1HafrLrp4/svE+vwR9M8ozowoBRyxutAKwJ7CM3LpwvJjEOA86q9a1Xy1RQVpfY0qqfjK1dCbxEVcH6dglR8JrrFxvqMHc1RPIsPWCziUtVQnWmKo0PbogDGN9bRTMxOF+8tA5naSP8Shp2x9CBKcut/nac/nghNtFjzsGbra5pp/eCxyWZ+Xlhp+lAppw/hElAzkv/F4X1bsZ2F9R7LBo9tTvpQkHJM/3yZuLkofLORef5zbZeSQI=",
          "X-HostAppCapabilities": "{\"isLokiContactDataDisabled\":false}"
        }
      }
      ws.send(pako.deflateRaw(JSON.stringify(request)))
    } catch (error) {
      console.log(error);
    }
  }


  ws.on('error', console.error);

  ws.on('open', function open() {
    console.log('connected');
    ['alexdu65200@gmail.com', 'carisey81@gmail.com', 'gregoire.bisso@gmail.com'].forEach((e) => makeRequest(e))
  });

  ws.on('message', async function message(data: Uint8Array | ArrayBuffer) {
    const dataSanitized = JSON.parse(pako.inflateRaw(data, { to: 'string' })).Body
    console.log('dataSanitized', dataSanitized)

    const cleanedData: Person = JSON.parse(dataSanitized).persons

    const educationHistory = cleanedData[0].schools.educationHistory.map((e: any) => ({
      school: {
        schoolName: e.school.schoolName ?? '',
        schoolLocation: e.school.schoolLocation ?? '',
        schoolLogo: e.school.schoolLogo ?? '',
        linkedInUrl: e.school.linkedInUrl ?? '',
      },
      degreeName: e.degreeName ?? '',
      startEndDate: {
        start: {
          month: e.startEndDate.start.month ?? '',
          year: e.startEndDate.start.year ?? '',
        },
        end: {
          month: e.startEndDate.end.month ?? '',
          year: e.startEndDate.end.year ?? '',
        },
      },
      fieldOfStudy: e.fieldOfStudy ?? '',
      schoolName: e.schoolName ?? '',
      schoolLocation: e.schoolLocation ?? '',
      schoolLogo: e.schoolLogo ?? '',
      linkedInUrl: e.linkedInUrl ?? '',
    }));

    output.push({
      firstName: cleanedData[0].firstName,
      lastName: cleanedData[0].lastName,
      displayName: cleanedData[0].displayName,
      emails: cleanedData[0].emails.map((e) => e).join(', '),
      phoneNumbers: cleanedData[0].phoneNumbers.map((e) => e).join(', '),
      headline: cleanedData[0].headline,
      location: cleanedData[0].location,
      companyName: cleanedData[0].companyName,
      photoUrl: cleanedData[0].photoUrl,
      linkedInUrl: cleanedData[0].linkedInUrl,
      connectionStatus: cleanedData[0].connectionStatus,
      schools: {
        educationsCount: cleanedData[0].schools.educationsCount,
        educationHistory,
      },
    })

    console.log('output', output)

    // console.log('received: %s', JSON.parse(pako.inflateRaw(data, { to: 'string' })));
  });

  // console.log('output', output)

  await Dataset.pushData(output);

  // await Actor.exit();

})();


src/mainws.ts

# configurations
.idea

# crawlee and apify storage folders
apify_storage
crawlee_storage
storage

# installed files
node_modules

# git folder
.git


.dockerignore

node_modules
logs/
storage/datasets/default/


.gitignore

//npm.pkg.github.com/:_authToken=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
@bebity:registry=https://npm.pkg.github.com
git-checks=false
```

.npmrc

crawlee-playwright-typescript

package.json

rombourg.valentin@orange.fr
relouzatbilel@gmail.com
ilias84elhani@gmail.com
bouabdellah_aymen@icloud.com
elliott.fernandes20@gmail.com
redon38100@hotmail.com
myriamsoa8@gmail.com
aoued38950@outlook.fr
theo-felix@hotmail.com
Nacerlaidioui@gmail.com
mohamedsy776@gmail.com
arrouaysalexis@gmail.com
Julesfernandez84@outlook.fr
andreas.noblet@yahoo.com
pierre.ribaillier6901@gmail.com
walid8301@hotmail.fr
laurane.ceccherini@gmail.com
kamil97605@gmail.com
lagdar_95@hotmail.fr
modzzzz77@gmail.com
jonathan.sema95@gmail.com
rilou.cherfi06@gmail.com
adiltht@gmail.com
theodiconcetto2407@gmail.com
davidcabre@hotmail.fr
sohaieb@hotmail.com
mehdikhalili@outlook.com
mehdi.bouabdellaoui@gmail.com
d.samake@live.fr
dipirro.mateo852@gmail.com
saadabaghafor56@gmail.com
moustapha953@outlook.fr
rmr1482002@gmail.com
yahia.mehdi@yahoo.fr
marzouckbankole@yahoo.com
chalal60@gmail.com
aconseiga@yahoo.com
mgaudencio@icloud.com
fouzia.ikouaias@sfr.fr
nico7594@hotmail.fr
hatim.ajbari@hotmail.fr
ghilane.zidane@gmail.com
jojodu069@live.fr
alphatygadiallo@gmail.com
edouard.debonnaire@gmail.com
wissamtaha3@gmail.com
alexis.behram@gmail.com
thomasvergne@me.com
rehioui.hedi@gmail.com
bouaichasufi@gmail.com
abderr6900@gmail.com
sofianesadki64@gmail.com
ami.belqadi@gmail.com
r.rousseaux@hotmail.com
zinedinebelkaidabdi@outlook.fr
rahimdjem@gmail.com
bellow.william@yahoo.fr
damieng24@outlook.fr
majiddriss119@gmail.com
kerroum.abderrahmane@gmail.com
sofyan.2144fc@gmail.com
a.laurain11@gmail.com
sam.elghorch@hotmail.com
ericpalcios7@gmail.com
laidouni.bilal@gmail.com
kerimlamenace@gmail.com
hamzasakho98@gmail.com
mo.elkaddouri1@gmail.com
solenndaniellou@gmail.com
rayane93430@gmail.com
diyarnom@gmail.com
tarik.tah@gmail.com
pelinavar66@icloud.com
lucas71210@hotmail.fr
mendess.loic@gmail.com
amina.carle4@gmail.com
valey.dylan@gmail.com
ch.motosse@gmail.com
vanessa.naomi64@gmail.com
tiago.cairrao93@gmail.com
mathieuavon0@gmail.com
sophie.bagtache@gmail.com
juliaderoeux@icloud.com
julien.mrchd@gmail.com
aimen.derghal@outlook.fr
dumontkevin83@gmail.com
dushelemerick@gmail.com
meriem.dahmani699@gmail.com
lokmanemzab@gmail.com
correiajohnny498@gmail.com
Mo.laoulaou@gmail.com
SK.anastasia@hotmail.fr
yaniiis837@gmail.com
bassdelbo@gmail.com
audre194969@gmail.com
ahmadounasaad@gmail.com
nicolas.bertin1904@gmail.com
colou.dylan@gmail.com
nihalkhay212@icloud.com
lahola1975@gmail.com
quentin-defreitas@laposte.net
pub95@hotmail.fr
coussin127@gmail.com
steevenelkourd@outlook.fr
kalilsylla94@gmail.com
manondeboffle212@outlook.fr
cazinisabelle@neuf.fr
guillaume.glt31@gmail.com
founs2405@hotmail.fr
loteandre32@gmail.com
hk.omar@hotmail.com
baptiste.0112@gmail.com
imloul.lisa@live.fr
nawfel0812@gmail.com
compaoreguemala13@gmail.com
diabyhabib1@gmail.com
rpeyyyy@gmail.com
jonathankamanda25@gmail.com
netanias973@gmail.com
alibaba88@hotmail.fr
julien.fiona@hotmail.com
dylanv006@hotmail.com
alexfont1304@gmail.com
thomasborges49@gmail.com
zongo.melvyn@gmail.com
oceanedasilvag@gmail.com
lorenzoperico92@outlook.fr
elkadiri.nabil97@gmail.com
vuillaume.vanessa@gmail.com
sofianeleguen@yahoo.com
salimfilali8@gmail.com
nbouzidi100@gmail.com
cogeay28@gmail.com
abdoulhassibabdoulaziz@gmail.com
aliazouzm@gmail.com
mm7981@gmail.com
nass_77000@hotmail.fr
brunodasilvaslb@gmail.com
lolita.michet2801@gmail.com
sugzknight@gmail.com
tifab94@gmail.com
fetyandreandrianirina@gmail.com
juju061080@gmail.com
Remaok19@gmail.com
fiona.vatbled@live.fr
degriaime@gmail.com
sarra6940@gmail.com
lucas38.ruti@gmail.com
jasonllvr@gmail.com
ervinlopci@gmail.com
boissyb@yahoo.fr
jeanjackdjakale@gmail.com
juleskouassi1987@gmail.com
peledu13@hotmail.fr
herediakyara@icloud.com
carreau.magali@gmail.com
jeremy.malard56@gmail.com
celineyvesvich@gmail.com
jbcorcelle@icloud.com
dpemma55@gmail.com
mourad-chaibi64@hotmail.fr
laurentbertier212@gmail.com
theo.tricart@laposte.net
kenzacris11@icloud.com
contact.mathrack@gmail.com
elvisllorensrenier@gmail.com
hugo_97441@hotmail.fr
mat.tauran@gmail.com
arnaudmmt@gmail.com
beenjii64@gmail.com
keutchakevin8@gmail.com
ffr.dragan@gmail.com
laura.dg0612@gmail.com
92i.ramane@gmail.com
sassimaissa59@gmail.com
hatem.boudiaf@gmail.com
csarah97470@gmail.com
bastienmarchand3@gmail.com
xianmbelo@gmail.com
sandy.evrard0613@orange.fr
cuvillezjennifer@msn.com
christelledauba@yahoo.fr
csarant86@gmail.com
kianki243@yahoo.com
eminadressemail@gmail.com
ayoubmourchid08@icloud.com


success2.txt

tsconfig.json

ℹ️ OSINT | LinkedInLens reveals the unseen! Turn mere email addresses into rich, detailed LinkedIn profiles. Even private profiles can't stay hidden anymore! Always be a step ahead in your marketing, recruiting, and more.

🔥 Linkedin Bulk Email Lookup

🔥 Linkedin Bulk Email Lookup · Apify

Input · 🔥 Linkedin Bulk Email Lookup · Apify

API · 🔥 Linkedin Bulk Email Lookup · Apify

Related Actors · 🔥 Linkedin Bulk Email Lookup · Apify

ℹ️ OSINT | LinkedInLens reveals the unseen! Turn mere email addresses into rich, detailed LinkedIn profiles. Even private profiles can't stay hidden anymore! Always be a step ahead in your marketin...

Where next?