LinkedIn & Indeed Job Sync for ERPNext

Key Features

`hooks.py` `doc_events` on `Job Opening` (`on_update`/`on_submit`) that enqueues auto-posting to LinkedIn and Indeed via `frappe.enqueue` background jobs

Bidirectional mapping layer translating ERPNext `Job Opening` fields (title, description, location, employment type) into each board's posting payload, storing returned external posting IDs on the opening

Whitelisted ingestion endpoint (`@frappe.whitelist(allow_guest=True)`) for LinkedIn Apply-Connect callbacks and Indeed applicant feeds, creating linked `Job Applicant` records

Resume/CV capture as a Frappe File attached to the created `Job Applicant`, with parsed name, email, and phone written to the DocType fields

Duplicate candidate detection on email and phone against existing `Job Applicant` records before insert, merging rather than duplicating cross-board applicants

Source/channel attribution field on `Job Applicant` populated from the originating board, feeding a Query Report or Script Report for cost-per-channel and source-of-hire analysis

Configuration DocType for per-board API credentials, OAuth tokens, and endpoint settings, encrypted via Frappe's password fieldtype

Per-board field-mapping DocType so title, category, employment type, and salary map correctly to each board's taxonomy without code changes

`scheduler_events` job (hourly or daily to respect API rate limits) that reconciles status back to the boards — pausing or closing postings when the ERPNext opening is filled or closed

Client Script on `Job Opening` surfacing live posting status per board plus a manual re-sync / retract action for recruiters

Retry and error-handling with entries in a sync-log DocType and `frappe.log_error`, so failed posts and rejected callbacks are visible and re-runnable

Dedicated Frappe Role and Role Profile gating who can trigger syncs, view board credentials, and read attribution reports

Idempotent posting logic keyed on the stored external posting ID to prevent duplicate listings when an opening is edited and re-saved

Built and tested against Frappe/ERPNext v15 and v16, packaged as a standalone app on your bench and versioned in git

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

You order

Start with a one-time build price. We scope it with you at kickoff.

We build & install

ECOSIRE builds, configures and installs it on your ERPNext.

Go live + support

You go live in about 2–4 weeks, with a post-launch support window.

About this Product

Recruiting teams running ERPNext HR already keep their pipeline in the Job Opening, Job Applicant, and Interview DocTypes, but the actual sourcing still happens on LinkedIn and Indeed. That means someone copies each opening into two job-board consoles by hand, then re-keys every inbound applicant back into ERPNext, losing which channel produced which hire along the way. ERPNext core ships a public Job Portal and a website Job Opening view, but it has no outbound connector to LinkedIn or Indeed, no Apply-Connect ingestion, and no cross-channel source attribution — so the multi-channel sourcing your recruiters actually do lives entirely outside the system of record.

ECOSIRE builds a proper Frappe app (its own app on the bench, versioned in git, with a dedicated module) that closes that loop. When a Job Opening is set to a publishable status, a hooks.py doc_events handler (on_update / on_submit) enqueues a background job via frappe.enqueue that maps the opening's title, description, location, and employment type to the LinkedIn and Indeed posting payloads and calls their APIs, storing the returned external posting IDs on the Job Opening so the ERPNext record stays the single source of truth. Inbound applicants flow the other way: a whitelisted endpoint (@frappe.whitelist(allow_guest=True)) receives LinkedIn Apply-Connect callbacks and Indeed applicant feeds, normalizes them, and creates Job Applicant records linked back to the correct opening — with the resume attached as a File and the originating board written into a source / channel field for reporting.

Under the hood we add configuration DocTypes (for API credentials, per-board field mappings, and sync settings), server scripts and controller methods for the transform logic, and a client script on Job Opening that surfaces posting status and a manual "re-sync" action for recruiters. Duplicate candidates are caught before insert by matching on email and phone against existing Job Applicant records, so the same person applying through both boards is merged rather than duplicated. A scheduler event (scheduler_events in hooks.py, hourly or daily to fit your API rate limits) reconciles status back to the boards — closing or pausing a posting on LinkedIn and Indeed when the ERPNext opening is filled or closed. Access is governed by ERPNext's permission system and a dedicated role / role profile so only HR and Recruiter users can trigger syncs or read board credentials. Everything targets Frappe/ERPNext v15 and v16 and is delivered against your bench, using the standard Frappe REST API and framework primitives rather than brittle scraping.

Because this is build-to-order, nothing ships until we agree on scope. We start with a short scoping call to confirm which boards, which openings qualify for auto-posting, your field mappings, and how you want attribution reported. From confirmed scope, typical delivery is 2-4 weeks: we build on a staging bench, run UAT with your recruiters, then install on your production bench with a rollback plan. You receive the full source in a git repository you own, plus documentation, training, and a post-go-live support window. LinkedIn and Indeed API access on the customer's own accounts (and any partner-program approval those boards require) is a prerequisite we help you navigate but do not resell.

What you get

Installable source code for your version of the app, as a standalone Frappe app on your bench

Installation and configuration on your staging and production benches, including board credential and field-mapping setup

Technical documentation: DocType schema, hooks, whitelisted endpoints, scheduler events, and API integration notes

Recruiter user guide plus a live training session for your HR and recruiting team

UAT on a staging bench with your real Job Openings and a documented rollback plan before production install

Post-go-live support window for defect fixes and configuration adjustments

Git repository handover with full commit history, ownership transferred to you

Board integration runbook covering LinkedIn/Indeed API prerequisites, token rotation, and rate-limit handling

Who this is for

In-house Recruiter / Talent Acquisition Lead

Runs multi-channel sourcing across LinkedIn and Indeed but is tired of copying openings into two consoles and re-keying every applicant. Wants postings and inbound candidates to live in ERPNext automatically, with no double entry.

HR Operations Manager

Owns the ERPNext HR module and the integrity of the `Job Applicant` pipeline. Needs source-of-hire and cost-per-channel reporting they can trust, plus role-based control over who can post to public job boards.

ERPNext Administrator / Frappe Developer

Maintains the bench and wants a clean, versioned app with proper hooks, DocTypes, and whitelisted methods — not scraping or hacks — that they can read, extend, and upgrade across v15 and v16.

Recruitment Agency Operations Owner

Manages high volumes of openings across many clients and needs reliable auto-posting, duplicate-candidate detection, and status sync so agency recruiters spend time on candidates, not data entry.

How LinkedIn & Indeed Job Sync for ERPNext Compares

Criterion	ECOSIRE	Custom Build	Competitor	ERPNext Native
Job-board posting from ERPNext	Auto-posts Job Openings to LinkedIn & Indeed via doc-event background jobs	Possible but you design and build the whole integration	Rarely covers both boards; often one channel or generic feed	No outbound board connector; only the built-in Job Portal
Applicant import to ATS	Apply-Connect/feed callbacks create linked `Job Applicant` records automatically	Build your own ingestion endpoints and normalization	Varies; import may be CSV or manual	Manual re-keying of applicants into ERPNext
Duplicate candidate detection	Email/phone match and merge before insert	Only if you implement it	Often absent or basic	None
Source/channel attribution	Per-board source field feeding cost-per-channel & source-of-hire reports	You build the reporting	Limited or single-source	No cross-channel attribution
Fit to your process	Scoped to your field mappings, boards, and reporting	Fully bespoke but fully on you	Fixed feature set, take it as-is	Generic HR module only
Upgrade safety (v15/v16)	Standalone app using hooks, DocTypes, whitelisted methods; no core patching	Depends on your engineering discipline	Depends on vendor maintenance	Native, but no feature to upgrade
Delivery model	Build-to-order in 2-4 weeks, UAT on staging + rollback plan	Long in-house build and QA cycle	Instant install but no fit-to-scope	Already installed; missing the capability
Ownership & support	Full git repo handover + post-go-live support window	You own and support everything alone	Vendor-controlled code; subscription support	Community/ERP vendor support, no connector

Frequently Asked Questions about LinkedIn & Indeed Job Sync for ERPNext

Is this an existing app I can download and install today?

No. It is build-to-order. ECOSIRE scopes, builds, and installs a version tailored to your boards, field mappings, and reporting needs. There is no instant download — you receive source code you own after we build it against your requirements.

How long does delivery take?

Typical delivery is 2-4 weeks from confirmed scope. After a short scoping call we build on a staging bench, run UAT with your recruiters, and then install on production. Timeline depends on how many boards, custom field mappings, and reporting requirements are in scope, plus how quickly board API access is granted.

What support and updates do I get after go-live?

Every build includes a post-go-live support window for defect fixes and configuration adjustments, plus the full git repository so your team can maintain and extend the app. We also validate it against Frappe/ERPNext v15 and v16; version-upgrade or feature-addition work beyond the support window is available as a follow-on engagement.

Do I need LinkedIn and Indeed API access?

Yes. Auto-posting and Apply-Connect ingestion run on your own LinkedIn and Indeed accounts, and both boards require partner-program or API approval for programmatic posting. We help you navigate the prerequisites and handle token setup, but ECOSIRE does not resell board access, and board policy and rate limits govern what is possible.

Will it create duplicate candidates when someone applies on both boards?

No. Before creating a `Job Applicant`, the app matches on email and phone against existing records and merges the application instead of creating a duplicate, while still recording each originating channel for source attribution.

How does it fit into ERPNext without breaking upgrades?

It is a standalone Frappe app on your bench that uses framework primitives — `hooks.py` doc events, whitelisted methods, scheduler events, configuration DocTypes, and client scripts — rather than patching ERPNext core. That keeps it upgrade-friendly across v15 and v16 and easy for your developers to read and extend.

Can recruiters control which openings get posted and re-sync manually?

Yes. A Client Script on `Job Opening` shows live posting status per board and gives recruiters a manual re-sync and retract action, while a dedicated role and role profile control who can trigger syncs or view board credentials.