# configurations
.idea

# crawlee and apify storage folders
apify_storage
crawlee_storage
storage

# installed files
node_modules

# git folder
.git

# dist folder
dist


.dockerignore

.gitignore

storage
apify_storage
crawlee_storage
node_modules
dist
tsconfig.tsbuildinfo
storage/*
!storage/key_value_stores
storage/key_value_stores/*
!storage/key_value_stores/default
storage/key_value_stores/default/*
!storage/key_value_stores/default/INPUT.json


.gitingore

indeed-scraper-actor

package.json

tsconfig.json

tsconfig.tsbuildinfo

# Specify the base Docker image.
FROM apify/actor-node-playwright-chrome:18 AS builder

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

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

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

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

# Create the final image
FROM apify/actor-node-playwright-chrome:18

# Set up the sysctl configuration
# USER root
# RUN echo 'kernel.unprivileged_userns_clone=1' > /etc/sysctl.d/userns.conf

# Apply the sysctl configuration
# RUN service procps restart

# Switch back to the myuser user
USER myuser

# Copy only built JS files from the builder image
COPY --from=builder --chown=myuser /home/myuser/dist ./dist

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

# 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 --legacy-peer-deps \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version

# 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 --chown=myuser . ./

# Run the image. If you know you won't need headful browsers,
# you can remove the XVFB start script for a micro perf gain.
CMD ./start_xvfb_and_run_cmd.sh && npm run start:prod


.actor/Dockerfile

indeed-jobs-scraper

Indeed jobs scraper

.actor/actor.json

Select country (default is worldwide) 
 Enhance accuracy by selecting the associated country (e.g., 'fr' for French jobs on fr.indeed.com). Data is drawn directly from country-specific indeed.com platforms, ensuring relevant outcomes for your location.

🗺️ Country

🔁 Unique or all

📅 From days

Select if you want to get job details. Enabling this option increases the number of requests made to fetch individual job details, potentially resulting in more network activity. If set to 'false', the crawler will only collect job list and few details, which may be more economical in terms of requests made.

📝 Get job details

📝 Job type

🧑‍🎓 Job level

Specify city, state, zip, or 'remote' positions. (For better accuracy, pair location with the relevant country. E.g., Paris, set country to 'France' for precise results.)

🌎 Location (city , state , zip code or 'remote')

🔢 Max rows

🔎 Query

📏 Radius

🏠 Site type

📑 Sort

Get data directly and fastly from Indeed

.actor/input_schema.json

exports.__esModule;
import { Actor } from "apify";
import { getJobsList, config } from "./lib/index.js";
import processJobLinks from "./lib/job-details";
import * as _ from "lodash";
import { countryFlag, countryName, countryURLs } from "./types/country";

export enum HireTypeEnum {
  directhire = "directhire",
}

export enum LevelEnum {
  entry_level = "entry_level",
  mid_level = "mid_level",
  senior_level = "senior_level",
}

export enum SortEnum {
  relevance = "relevance",
  date = "date",
}

export enum SiteTypeEnum {
  jobsite = "jobsite",
  employer = "employer",
}

export enum JobTypeEnum {
  fulltime = "fulltime",
  parttime = "parttime",
  contract = "contract",
  internship = "internship",
  temporary = "temporary",
  commission = "commission",
}

export enum DuplicateEnum {
  unique = "unique",
  all = "all",
}

export type OriginalInput = {
  query: string;
  hiretype?: HireTypeEnum;
  level?: LevelEnum;
  salary?: string;
  radius?: number;
  location?: string;
  sort?: SortEnum;
  sitetype?: SiteTypeEnum;
  jobtype?: JobTypeEnum;
  fromdays?: number;
  duplicate?: DuplicateEnum;
  maxperpage?: number;
};

export type Input = {
  country?: string;
  query: string;
  maxRows: number;
  level?: LevelEnum;
  radius?: number;
  location?: string;
  sort?: SortEnum;
  sitetype?: SiteTypeEnum;
  jobtype?: JobTypeEnum;
  fromdays?: number;
  duplicate?: DuplicateEnum;
  getJobDetails?: boolean;
};

(async () => {
  await Actor.init();

  let input: Input = (await Actor.getInput()) as Input;

  if (input.query === undefined) {
    input.query = "&nbsp;";
    console.error("❗️ Missing query input value");
  }

  if (input.maxRows === undefined) {
    console.error("❗️ Missing maxRows input value");
  }

  config["max-pages"] =
    input?.maxRows <= 50 || !input?.maxRows ? 1 : Math.ceil(input.maxRows / 50); //the maximum number of visited pages

  const country = countryURLs[input.country];

  if (!country)
    console.error(
      "🚫 Country information not provided, defaulting to 🌎 worldwide location. Results may be affected."
    );
  else
    console.info(
      "🏴 Search in country :",
      countryFlag[input.country],
      countryName[input.country]
    );

  config["base-URL"] = country ?? "https://www.indeed.com";
  config["verbose"] = true; //to deliver information about current processing

  const rslt = await getJobsList({
    ..._.omit(input, ["maxRows"]),
    maxperpage:
      input?.maxRows !== undefined
        ? input.maxRows <= 50
          ? input.maxRows
          : 50
        : 15,
  });

  console.info("📋 Found", rslt.length, "jobs");

  if (input?.getJobDetails === false) await Actor.pushData(rslt);
  else {
    const jobLinks = rslt.map(
      (job) =>
        `${country ?? "https://indeed.com"}/viewjob?jk=${
          job.jobKey
        }&from=vjs&spa=1`
    );

    // Process job details
    const processedData = await processJobLinks(jobLinks);

    console.info("ℹ️ Processed", processedData.length, "job details");
  }
  await Actor.exit();
})();


src/main.ts

src/lib/browser.js

src/lib/config.js

let { parse } 	 					   = require("url");
let PageParser 						   = require("./page-parser.js");
let BrowserPage    					   = require("./browser.js");
let { filterParams , checkParamValue } = require("./utils/validator.js");
let config     						   = require("./config.js");
let PdfGenerator 					   = require("./pdfGenerator.js");

//-----------------------------------------------------------------------------

function getJobsList(params) {
	let page  = new BrowserPage();
	params    = checkParamValue(filterParams(params));
	let limit = config["max-pages"];

	let jobs  = (function _getJobsList(params , jobs = []) {
		if(limit-- === 0) return Promise.resolve(jobs);
		let url = new URL("jobs" , config["base-URL"]);
		return page.getContent(url, params).then((content) => {
			if(config["verbose"]) console.log("\u2714" , url.href);
			let parser = new PageParser(content);
			let { pageJobs , nextLink } = parser.getContent();
			jobs = jobs.concat(pageJobs);
			if(nextLink === null) return jobs;
			else return _getJobsList(parse(nextLink , true)["query"] , jobs);
		})
	})(params , []);

	return jobs.then((jobs) => {
		return page.closeBrowser().then(() => jobs);
	});
}

//-----------------------------------------------------------------------------

function getJobsPDF(params) {
	return getJobsList(params).then((jobs) => {
		if(config["verbose"]) console.log("\u2714 generating PDF buffer starts...");
		return (new PdfGenerator(jobs)).generatePDF().then((buffer) => {
			if(config["verbose"]) console.log("\u2714 generating PDF buffer finished...");
			return buffer;
		})
	})
}

//-----------------------------------------------------------------------------

function release() {
	return BrowserPage.closeBrowser();
}

//-----------------------------------------------------------------------------

exports.getJobsList = getJobsList;
exports.getJobsPDF  = getJobsPDF;
exports.release     = release;
exports.config      = config;

src/lib/index.js

import { Actor, LogLevel, log } from "apify";
import { CheerioCrawler } from "crawlee";
import * as _ from "lodash";

async function processJobLinks(jobLinks: string[]) {
  const data = [];

  const proxyConfiguration = await Actor.createProxyConfiguration({
    groups: ["RESIDENTIAL"],
  });

  log.setLevel(LogLevel.OFF);

  const crawler = new CheerioCrawler({
    proxyConfiguration,
    async requestHandler({ body }) {
      const result = JSON.parse(body as string).body;

      const keysToExclude = [
        "ctk",
        "base64EncodedJson",
        "shouldLogResolution",
        "shareJobButtonContainerModel",
        "segmentPhoneNumberButtonLinkModel",
        "segmentId",
        "saveJobLimitExceededModalModel",
        "saveJobFailureModalModel",
        "saveJobButtonContainerModel",
        "salaryGuideModel.acmeMicrocontentEndpoint",
        "requestPath",
        "localeData",
        "resumeFooterModel",
        "resumePromoCardModel",
        "rtl",
        "loggedIn",
        "mobResourceTimingEnabled",
        "mobtk",
        "lastVisitTime",
        "lazyProviders",
        "jobSeenData",
        "mosaicData",
        "oneGraphApiKey",
        "oneGraphApiUrl",
        "originalJobLinkModel",
        "pageId",
        "parenttk",
        "phoneLinkType",
        "preciseLocationModel",
        "profileBaseUrl",
        "queryString",
        "recentQueryString",
        "recommendedJobsModel",
        "recommendedSearchesModel",
        "shouldShowConditionalBackButton",
        "showEmployerResponsiveCard",
        "showGlobalNavContent",
        "showReportInJobButtons",
        "staticPrefix",
        "stickyType",
        "successfullySignedInModel",
        "thirdPartyAndMobile",
        "thirdPartyQuestionsToggle",
        "viewJobButtonLinkContainerModel",
        "viewJobDisplay",
        "viewJobDisplayParam",
        "viewjobDislikes",
        "whatWhereFormModel",
        "workplaceInsightsModel",
        "zoneProviders",
        "accountKey",
        "apiPaths",
        "apolloCachedResponse",
        "appCommonData",
        "applyButtonSDKEnabled",
        "autoClickApply",
        "baseInboxUrl",
        "baseUrl",
        "callToInterviewButtonModel",
        "categorizedAttributesModel",
        "chatbotApplyButtonLinkModel",
        "clientsideProctorGroups",
        "cmiJobCategoryModel",
        "collapsedDescriptionPayload",
        "commuteInfoModel",
        "companyAvatarModel.a11yNewtabIconActive",
        "companyAvatarModel.companyAlertI18nActive",
        "companyAvatarModel.cta",
        "companyAvatarModel.followButtonPresent",
        "companyAvatarModel.headline",
        "companyAvatarModel.openCompanyLinksInNewTab",
        "companyFollowFormModel",
        "cssResetProviders",
        "dcmModel",
        "desktop",
        "dgToken",
        "dislikeFrom2paneEnabled",
        "downloadAppButtonModel",
        "employerResponsiveCardModel",
        "from",
        "globalnavFooterHTML",
        "globalnavHeaderHTML",
        "highQualityMarketplace",
        "highQualityMarketplaceHiringManager",
        "hiringInsightsModel.employerResponsiveCardModel",
        "indeedApplyButtonContainer",
        "indeedLogoModel",
        "inlineJsErrEnabled",
        "isApp",
        "isApplyTextColorChanges",
        "isApplyTextSizeChanges",
        "isCriOS",
        "isDislikeFormV2Enabled",
        "isSafariForIOS",
        "isSalaryNewDesign",
        "isSyncJobs",
        "jasJobViewPingModel",
        "jasxInputWhatWhereActive",
        "jobAlertSignInModalModel",
        "jobAlertSignUp",
        "jobCardStyleModel",
      ];

      const sanitedData = _.omit(result, keysToExclude);

      const companyName =
        sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
          ?.companyName || sanitedData.companyAvatarModel?.companyName;

      const output = {
        jobKey: sanitedData.jobKey,
        location: sanitedData.jobLocation,
        company: {
          companyName: companyName,
          companyOverviewLink:
            sanitedData.companyAvatarModel?.companyOverviewLink ||
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.companyOverviewLink,
          companyReviewLink:
            sanitedData.companyAvatarModel?.companyReviewLink ||
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.companyReviewLink,
          companyLogoUrl:
            sanitedData.companyAvatarModel?.companyLogoUrl ||
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.companyImagesModel?.logoUrl,
          headerImageUrl:
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.companyImagesModel?.headerImageUrl,
          companyDescription:
            sanitedData.companyAvatarModel?.companyDescription,
          companyRating: {
            ariaContent:
              sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
                ?.companyReviewModel?.ratingsModel?.ariaContent,
            count:
              sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
                ?.companyReviewModel?.ratingsModel?.count,
            countContent:
              sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
                ?.companyReviewModel?.ratingsModel?.countContent,
            rating:
              sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
                ?.companyReviewModel?.ratingsModel?.rating,
          },
        },
        jobInfo: {
          formattedLocation:
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.formattedLocation,
          jobTitle:
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.jobTitle,
          jobDescription:
            sanitedData.jobInfoWrapperModel?.jobInfoModel
              ?.sanitizedJobDescription,
          remoteLocation:
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobInfoHeaderModel
              ?.remoteLocation,
          remoteWorkModel: {
            text: sanitedData.jobInfoWrapperModel?.jobInfoModel
              ?.jobInfoHeaderModel?.remoteWorkModel?.text,
            type: sanitedData.jobInfoWrapperModel?.jobInfoModel
              ?.jobInfoHeaderModel?.remoteWorkModel?.type,
          },
          jobTypes:
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobDescriptionSectionModel?.jobDetailsSection?.jobTypes?.map(
              (item) => item
            ),
          shiftsAndSchedule:
            sanitedData.jobInfoWrapperModel?.jobInfoModel?.jobDescriptionSectionModel?.jobDetailsSection?.shiftsAndSchedule?.map(
              (item) => item?.label
            ),
          benefitsModel: sanitedData.benefitsModel?.benefits?.map(
            (item) => item?.label
          ),
        },
        jobMetadata: {
          age:
            sanitedData.jobMetadataFooterModel?.age ||
            sanitedData.hiringInsightsModel?.age,
          source: sanitedData.jobMetadataFooterModel?.source,
          originalJobLink:
            sanitedData.jobMetadataFooterModel?.originalJobLink?.href,
          phoneNumber: sanitedData.jobMetadataFooterModel?.phoneNumber,
          postedToday: sanitedData.hiringInsightsModel?.postedToday,
          numOfCandidate: sanitedData.hiringInsightsModel?.numOfCandidates,
          urgentlyHiring:
            sanitedData.hiringInsightsModel?.urgentlyHiringModel?.type ===
            "URGENTLY_HIRING"
              ? true
              : false,
          jobUrl: `https://indeed.com/viewjob?jk=${sanitedData.jobKey}&from=native`,
        },
        language: sanitedData.language,
        locale: sanitedData.locale,
        salaryGuide: {
          formattedLocation: sanitedData.salaryGuideModel?.formattedLocation,
          estimatedSalary: sanitedData.salaryGuideModel?.estimatedSalaryModel,
          country: sanitedData.salaryGuideModel?.country,
        },
        salaryInfo: {
          salaryMax: sanitedData.salaryInfoModel?.salaryMax,
          salaryMin: sanitedData.salaryInfoModel?.salaryMin,
          salaryType: sanitedData.salaryInfoModel?.salaryType,
          salaryText: sanitedData.salaryInfoModel?.salaryText,
          indeedEstimateText: sanitedData.salaryInfoModel?.indeedEstimateText,
          salarySource: sanitedData.salaryInfoModel?.salarySource,
        },
        relatedLinks: sanitedData.relatedLinks,
        additionalLinks: {
          similarCategoryLinks:
            sanitedData.additionalLinksViewModel?.similarCategoryLinks?.map(
              (link) => ({
                surfaceElementLabel: link.surfaceElementLabel,
                surfaceElementUrl: link.surfaceElementUrl,
              })
            ),
          similarJobTitleLinks:
            sanitedData.additionalLinksViewModel?.similarJobTitleLinks?.map(
              (link) => ({
                surfaceElementLabel: link.surfaceElementLabel,
                surfaceElementUrl: link.surfaceElementUrl,
              })
            ),
        },
        sponsored: sanitedData.sponsored,
      };

      data.push(output);
      await Actor.pushData(output)
    },
  });

  // Add job link requests to the crawler
  const requests = jobLinks.map((link) => ({
    url: link,
    userData: { label: "DETAIL" },
  }));

  await crawler.addRequests(requests);
  await crawler.run();

  return data;
}

export default processJobLinks;


src/lib/job-details.ts

src/lib/page-parser.js

src/lib/pdfGenerator.js

src/lib/request.js

src/lib/utils/validator.js

interface CountryURLMap {
    [countryCode: string]: string;
}

interface CountryFlagMap {
    [countryCode: string]: string;
}

interface CountryNameMap {
    [countryCode: string]: string;
}

export const countryURLs: CountryURLMap = {
    ar: 'https://ar.indeed.com',
    au: 'https://au.indeed.com',
    at: 'https://at.indeed.com',
    bh: 'https://bh.indeed.com',
    be: 'https://be.indeed.com',
    br: 'https://br.indeed.com',
    ca: 'https://ca.indeed.com',
    cl: 'https://cl.indeed.com',
    cn: 'https://cn.indeed.com',
    co: 'https://co.indeed.com',
    cz: 'https://cz.indeed.com',
    dk: 'https://dk.indeed.com',
    fi: 'https://fi.indeed.com',
    fr: 'https://fr.indeed.com',
    de: 'https://de.indeed.com',
    gr: 'https://gr.indeed.com',
    hk: 'https://hk.indeed.com',
    hu: 'https://hu.indeed.com',
    in: 'https://in.indeed.com',
    id: 'https://id.indeed.com',
    ie: 'https://ie.indeed.com',
    il: 'https://il.indeed.com',
    it: 'https://it.indeed.com',
    jp: 'https://jp.indeed.com',
    kw: 'https://kw.indeed.com',
    lu: 'https://lu.indeed.com',
    my: 'https://my.indeed.com',
    mx: 'https://mx.indeed.com',
    ma: 'https://ma.indeed.com',
    nl: 'https://nl.indeed.com',
    nz: 'https://nz.indeed.com',
    no: 'https://no.indeed.com',
    om: 'https://om.indeed.com',
    pe: 'https://pe.indeed.com',
    ph: 'https://ph.indeed.com',
    pl: 'https://pl.indeed.com',
    pt: 'https://pt.indeed.com',
    qa: 'https://qa.indeed.com',
    ro: 'https://ro.indeed.com',
    ru: 'https://ru.indeed.com',
    sa: 'https://sa.indeed.com',
    sg: 'https://sg.indeed.com',
    za: 'https://za.indeed.com',
    kr: 'https://kr.indeed.com',
    es: 'https://es.indeed.com',
    se: 'https://se.indeed.com',
    ch: 'https://ch.indeed.com',
    tw: 'https://tw.indeed.com',
    tr: 'https://tr.indeed.com',
    ua: 'https://ua.indeed.com',
    ae: 'https://ae.indeed.com',
    uk: 'https://uk.indeed.com',
    us: 'https://www.indeed.com',
    ve: 'https://ve.indeed.com',
    vn: 'https://vn.indeed.com'
};

export const countryFlag: CountryFlagMap = {
    ar: '🇦🇷',
    au: '🇦🇺',
    at: '🇦🇹',
    bh: '🇧🇭',
    be: '🇧🇪',
    br: '🇧🇷',
    ca: '🇨🇦',
    cl: '🇨🇱',
    cn: '🇨🇳',
    co: '🇨🇴',
    cz: '🇨🇿',
    dk: '🇩🇰',
    fi: '🇫🇮',
    fr: '🇫🇷',
    de: '🇩🇪',
    gr: '🇬🇷',
    hk: '🇭🇰',
    hu: '🇭🇺',
    in: '🇮🇳',
    id: '🇮🇩',
    ie: '🇮🇪',
    il: '🇮🇱',
    it: '🇮🇹',
    jp: '🇯🇵',
    kw: '🇰🇼',
    lu: '🇱🇺',
    my: '🇲🇾',
    mx: '🇲🇽',
    ma: '🇲🇦',
    nl: '🇳🇱',
    nz: '🇳🇿',
    no: '🇳🇴',
    om: '🇴🇲',
    pe: '🇵🇪',
    ph: '🇵🇭',
    pl: '🇵🇱',
    pt: '🇵🇹',
    qa: '🇶🇦',
    ro: '🇷🇴',
    ru: '🇷🇺',
    sa: '🇸🇦',
    sg: '🇸🇬',
    za: '🇿🇦',
    kr: '🇰🇷',
    es: '🇪🇸',
    se: '🇸🇪',
    ch: '🇨🇭',
    tw: '🇹🇼',
    tr: '🇹🇷',
    ua: '🇺🇦',
    ae: '🇦🇪',
    uk: '🇬🇧',
    us: '🇺🇸',
    ve: '🇻🇪',
    vn: '🇻🇳',
};

export const countryName: CountryNameMap = {
    ar: 'Argentina',
    au: 'Australia',
    at: 'Austria',
    bh: 'Bahrain',
    be: 'Belgium',
    br: 'Brazil',
    ca: 'Canada',
    cl: 'Chile',
    cn: 'China',
    co: 'Colombia',
    cz: 'Czech Republic',
    dk: 'Denmark',
    fi: 'Finland',
    fr: 'France',
    de: 'Germany',
    gr: 'Greece',
    hk: 'Hong Kong',
    hu: 'Hungary',
    in: 'India',
    id: 'Indonesia',
    ie: 'Ireland',
    il: 'Israel',
    it: 'Italy',
    jp: 'Japan',
    kw: 'Kuwait',
    lu: 'Luxembourg',
    my: 'Malaysia',
    mx: 'Mexico',
    ma: 'Morocco',
    nl: 'Netherlands',
    nz: 'New Zealand',
    no: 'Norway',
    om: 'Oman',
    pe: 'Peru',
    ph: 'Philippines',
    pl: 'Poland',
    pt: 'Portugal',
    qa: 'Qatar',
    ro: 'Romania',
    ru: 'Russia',
    sa: 'Saudi Arabia',
    sg: 'Singapore',
    za: 'South Africa',
    kr: 'South Korea',
    es: 'Spain',
    se: 'Sweden',
    ch: 'Switzerland',
    tw: 'Taiwan',
    tr: 'Turkey',
    ua: 'Ukraine',
    ae: 'United Arab Emirates',
    uk: 'United Kingdom',
    us: 'United States',
    ve: 'Venezuela',
    vn: 'Vietnam',
};


src/types/country.ts

interface Company {
    companyName: string;
    companyRating: Record<string, any>;
  }
  
  interface RemoteWorkModel {
    text: string;
    type: string;
  }
  
  interface JobInfo {
    formattedLocation: string;
    jobTitle: string;
    jobDescription: string;
    remoteLocation: boolean;
    remoteWorkModel: RemoteWorkModel;
    jobTypes: string[];
  }
  
  interface JobMetadata {
    age: string;
    source: string;
    originalJobLink: string;
    postedToday: boolean;
    numOfCandidate: string;
    urgentlyHiring: boolean;
    jobUrl: string;
  }
  
  interface SalaryGuide {
    formattedLocation: string;
    estimatedSalary: string;
    country: string;
  }
  
  interface SalaryInfo {
    salaryMax: number;
    salaryMin: number;
    salaryType: string;
    salaryText: string;
    indeedEstimateText: string;
    salarySource: string;
  }
  
  interface RelatedLink {
    href: string;
    linkText: string;
    what: string;
    where: string;
  }
  
  interface AdditionalLinks {
    similarCategoryLinks: Record<string, string>[];
    similarJobTitleLinks: Record<string, string>[];
  }
  
  export interface Job {
    jobKey: string;
    location: string;
    company: Company;
    jobInfo: JobInfo;
    jobMetadata: JobMetadata;
    language: string;
    locale: string;
    salaryGuide: SalaryGuide;
    salaryInfo: SalaryInfo;
    relatedLinks: RelatedLink[];
    additionalLinks: AdditionalLinks;
    sponsored: boolean;
  }


src/types/jobs.ts

🚀 Explore job opportunities effortlessly with the Indeed Jobs Scraper Apify Actor. Input your criteria, fetch targeted listings, and streamline your job search. Advanced filters, intuitive UI, and precise data at your fingertips! 🌟🔍📊

🔥 Indeed Jobs Scraper

🔥 Indeed Jobs Scraper · Apify

Input · 🔥 Indeed Jobs Scraper · Apify

API · 🔥 Indeed Jobs Scraper · Apify

Related Actors · 🔥 Indeed Jobs Scraper · Apify

🚀 Explore job opportunities effortlessly with the Indeed Jobs Scraper Apify Actor. Input your criteria, fetch targeted listings, and streamline your job search. Advanced filters, intuitive UI, and...

Where next?