Many organisations still feed SaaS applications from an LDAP directory through scheduled sync jobs and connectors, and those jobs are often the weakest link when someone leaves. LDAP and SCIM are not competing ways of doing the same thing: LDAP is a protocol for reading and writing a directory, while SCIM is a protocol for pushing identity lifecycle changes into an application. The question most teams actually face is narrower: should the connector that polls the directory and writes accounts into a SaaS tenant be replaced by SCIM provisioning from an identity provider? This guide answers that question for hybrid estates, covering how each model carries joiners, movers and leavers, where deprovisioning silently fails, how to migrate, and what to measure. It is for IAM engineers, directory owners and application owners. For authentication protocols (LDAP bind versus SAML and OpenID Connect) see the LDAP vs SAML vs OIDC guide; this page is about provisioning. Example platforms are listed alphabetically, and order is never a ranking.
Key takeaways
- Different jobs, often confused. LDAP (RFC 4511) defines operations such as Search, Add, Modify and Delete against a directory tree; SCIM (RFC 7643 and RFC 7644) defines a REST schema and protocol for creating, updating and suspending users and groups in another system.
- LDAP sync is pull, SCIM is push. A sync connector reads the directory on a schedule and infers what changed; a SCIM client sends an explicit request, such as a PATCH setting
activeto false, when the source changes. - Deletes are the hard part of LDAP sync. A plain LDAP Search returns what exists, not what was removed, so a connector must compare full exports or rely on server features such as the RFC 4533 sync operation or an access log overlay to see deletions.
- SCIM moves the risk, it does not remove it. SCIM replaces a directory service account with a bearer token or OAuth client that can create and disable users in the application, a privileged non-human identity that needs rotation and monitoring.
- Hybrid is normal. Keep LDAP where on-premises applications genuinely need a directory, feed SaaS through SCIM from the identity provider, and make one system authoritative for each attribute.
What each protocol actually does
LDAP is defined in RFC 4511 (Standards Track, June 2006). It is a client to directory protocol: Bind authenticates the client, Search retrieves entries that match a filter under a base DN, and Add, Modify, Delete and Modify DN change entries. StartTLS upgrades a connection on port 389, and LDAPS uses port 636. Nothing in LDAP describes a person's lifecycle or an application account: it describes entries and attributes in a directory information tree. When people talk about "LDAP provisioning" they mean a separate product (a sync engine, an agent or a custom script) that uses LDAP as its read or write channel.
SCIM is defined in RFC 7643 (core schema) and RFC 7644 (protocol), both Proposed Standards from September 2015; the RFC Editor now lists RFC 9865 and RFC 9967 as updates to both (checked November 2026). SCIM defines User and Group resources, the enterprise user extension (employeeNumber, department, manager and similar) and REST operations over HTTPS. RFC 7643 defines active as a Boolean for the user's administrative status, where false typically means the account is suspended. RFC 7644 does not define its own authentication: it relies on TLS plus standard HTTP schemes such as OAuth 2.0 bearer tokens, and requires that every authenticated client maps to an access control policy.
The practical difference: LDAP gives a connector the ability to read a directory, SCIM gives an identity provider a standard way to tell an application what should be true. See the SCIM Provisioning Guide for the SCIM mechanics in depth and the LDAP Security Deep Dive for the directory side.
Side-by-side comparison
| Dimension | LDAP sync or connector | SCIM provisioning |
|---|---|---|
| Standard | RFC 4511 for the protocol; the sync logic is product specific | RFC 7643 schema and RFC 7644 protocol |
| Direction of control | Connector pulls from the directory, then writes to the target | Identity provider pushes to the application's SCIM endpoint |
| Change detection | Full export comparison, change logs, RFC 4533 sync cookies or vendor delta features | Source system knows the change and sends it |
| Leaver signal | Inferred: an entry disappears, moves OU or gains a disabled flag | Explicit: PATCH active false, or DELETE |
| Disabled state | No standard attribute; varies by directory (for example msDS-UserAccountDisabled in AD LDS) | Standard active attribute, meaning defined by the application |
| Network path | Agent or connector needs reach to the directory on 389 or 636 | Outbound HTTPS from the identity provider to the application |
| Integration credential | Directory bind account, often with broad read rights | Bearer token, OAuth client credentials or federated token |
| Groups | Read as group entries and memberships, mapped by the connector | Optional Group resource; support varies per application |
| Typical use today | On-premises apps, legacy SaaS connectors, directory to directory sync | SaaS and cloud platforms fed from a cloud identity provider |
Threat model: LDAP-based sync
An LDAP sync connector has three assets an attacker cares about: the bind credential, the agent host and the integrity of the data it reads.
- Bind account exposure: sync jobs usually bind as a service account with read access to every user and group in scope. The password often sits in a connector configuration file or scheduler, rarely rotates and is shared across jobs. Anyone holding it can enumerate the directory. See the OpenLDAP Security Hardening Guide for limiting what a bind identity can read.
- Cleartext transport: a connector configured for simple bind on port 389 without StartTLS sends the bind password in clear. Require LDAPS (636) or StartTLS and certificate validation on every connector.
- Agent host as a pivot: on-premises agents sit inside the network with both directory credentials and a channel to a cloud tenant. Treat the host as tier 0 or tier 1 infrastructure, not a utility server.
- Directory as the attack surface: whoever can write to the source OU or group can grant SaaS access, because the connector trusts what it reads. Directory delegation errors become application access errors.
Failure modes specific to LDAP sync: missed deletes when the job sees only current entries, silent job failure because nobody watches the scheduler, filter drift when an OU is renamed and users fall out of scope (which some connectors treat as a delete and others ignore), and reads capped by server size limits that truncate the export. RFC 4533 itself notes that a server may return e-syncRefreshRequired when incremental sync is not possible, forcing a full reload; connectors that do not handle this can stall.
Threat model: SCIM provisioning
- The SCIM credential is privileged: it can create users, change attributes and in some applications assign admin groups. A leaked token is an account creation capability. Prefer OAuth client credentials or token federation where the platform supports it, and scope the token to provisioning only.
- Endpoint exposure: the application's SCIM endpoint is internet facing by design. RFC 7644 Section 2 discourages basic authentication and expects TLS; Microsoft's SCIM guidance for Entra ID states that TLS 1.2 is the only acceptable version.
- Upstream compromise: SCIM faithfully replicates whatever the identity provider holds, so an attacker who can add a user to an assigned group gets provisioned everywhere that group is pushed.
- Drift from side channels: admins or APIs that change accounts directly in the application create state SCIM does not know about. AWS documents this for IAM Identity Center: mutating Identity Store API calls can cause drift because SCIM syncs operate on deltas.
Failure modes specific to SCIM: token expiry that stops sync without anyone noticing, applications that accept active false but leave API tokens and sessions alive, unsupported multivalue attributes that make whole user records fail, and unassignment semantics that stop management of a user. In Entra ID, unassigning a user sends a disable and the service then stops managing that user, so a later directory delete is not sent. The SCIM Provisioning Errors Troubleshooting Guide covers the error side.
Deprovisioning reliability: where each model breaks
The reason most teams move from LDAP sync to SCIM is the leaver. The table compares the same leaver event under both models.
| Leaver step | LDAP sync behaviour | SCIM behaviour | Control |
|---|---|---|---|
| HR terminates the worker | Directory entry disabled or moved; connector learns at next run | Identity provider disables the user; next provisioning cycle sends the change | Measure source to target latency per application |
| Account disable in target | Depends on the connector mapping a disabled flag; many directories have no standard inactive attribute | PATCH with active false | Test disable explicitly during onboarding of each app |
| Entry deleted at source | Seen only through full comparison, change log or sync protocol | DELETE sent on hard delete (Entra ID: after the 30 day soft delete window) | Reconcile target accounts against source monthly |
| Job or integration failure | Scheduler error, often unmonitored | Quarantine or token expiry alerts in the identity provider | Alert on failed or stalled cycles within one cycle interval |
| Local credentials in the app | Untouched by either model unless the app revokes them on suspension | Same | Confirm per app that suspension revokes tokens and keys |
Two documented behaviours illustrate the timing. Microsoft states that Entra ID runs a SCIM provisioning cycle every 40 minutes, and that if a job is quarantined because calls keep failing, incremental cycles drop to once per day and the job is disabled after more than four weeks in quarantine. Google documents that Cloud Directory Sync performs a one-way synchronisation in which a list is exported from the LDAP server during each sync and the LDAP data is never altered: its leaver timing is set by how often the sync is scheduled. Neither number is a promise for your estate: measure it. See SaaS deprovisioning and the Employee Offboarding Security Guide for what has to happen beyond the account.
Hybrid estates: one source, two delivery channels
Most organisations that ask this question still run Active Directory or another LDAP directory, plus a cloud identity provider and dozens of SaaS tenants. The common target architecture is:
- HR is the source of truth for people. Joiner, mover and leaver events start in the HR system and flow into the directory and identity provider. See the Identity Lifecycle Event Design Guide.
- The directory and identity provider are synchronised once. A single sync path (for example Microsoft Entra Connect or Cloud Sync for Active Directory) keeps them aligned, hardened as tier 0. See the Microsoft Entra Connect and Cloud Sync Hardening Guide.
- SaaS is fed by SCIM from the identity provider, not by per-application LDAP connectors.
- On-premises LDAP consumers stay on LDAP, and the identity provider can write to them where needed. Microsoft documents provisioning from Entra ID into LDAP directories such as OpenLDAP, AD LDS and 389 Directory Server through the provisioning agent and the ECMA Connector Host, with Full Import, Export and optional Delta Import run profiles; it does not support provisioning into Active Directory Domain Services through that route, does not provision groups or memberships, and recommends SAML, OAuth or OpenID Connect rather than LDAP for authentication.
The rule that keeps this safe: each attribute has exactly one authoritative writer. If both an LDAP connector and SCIM write department into the same application, they will fight, and the loser is your access model.
Platform examples (alphabetical)
- Amazon Web Services: IAM Identity Center accepts SCIM v2.0 from an external identity provider using a bearer token valid for one year, with expiry reminders from 90 days; when the token expires, synchronisation stops. Once SCIM is enabled, users cannot be added or edited in the console. Availability: users need first name, last name, username and display name, and multivalue attributes are not provisioned. See the AWS IAM Identity Center Guide.
- Google: Cloud Directory Sync reads users, groups and shared contacts from Active Directory or an LDAP server using rules that define the list to export, and syncs one way into Google Workspace; exclusion rules omit data from the sync. See the Google Workspace Security Checklist.
- Microsoft: Entra ID acts as a SCIM client for SaaS applications on a 40 minute cycle, and authenticates to the application with OAuth 2.0 client credentials, workload identity federation or, for existing and non-gallery apps, a long-lived bearer token; it also provisions into LDAP directories through the ECMA Connector Host. Availability: the LDAP connector requires Entra ID P1 or P2. See the Microsoft Entra Connect and Cloud Sync Hardening Guide.
Decision criteria: when to keep LDAP sync and when to move to SCIM
| Situation | Choose | Why |
|---|---|---|
| SaaS application offers SCIM and your identity provider supports it | SCIM | Explicit disable, standard schema, no inbound path to the directory |
| On-premises application reads accounts from a directory | LDAP (fed by the identity provider or the master directory) | The application needs a directory; SCIM is not its interface |
| SaaS application offers only an LDAP sync agent | Keep LDAP sync, harden it, and record a SCIM roadmap request | Replacing it with manual work is worse |
| Directory to directory replication (for example to a cloud directory) | Vendor sync tool, one path only | A dedicated sync engine handles anchors and writeback |
| Application issues local API tokens or SSH keys | SCIM, plus confirmed revocation on suspension | The leaver signal must arrive and must kill credentials |
| Very small organisation without a cloud identity provider | LDAP sync with monitored scheduling and monthly reconciliation | SCIM needs an identity provider acting as the client |
Small organisations: the realistic move is to adopt a cloud identity provider for SSO and SCIM, and retire per-application LDAP scripts one by one. Large organisations: make SCIM support a procurement requirement for SaaS above a data classification threshold, and run LDAP connectors only as documented exceptions with an owner and review date. The SSO vs SCIM guide covers the related sign-in versus lifecycle split, and SCIM vs JIT Provisioning covers the sign-in creation alternative.
Migration: replacing an LDAP connector with SCIM
- Inventory: list every job that reads the directory and writes to an application: scheduler entries, agents, scripts, and the bind accounts they use. Directory logs of binds by service accounts are the fastest way to find forgotten ones.
- Choose the matching attribute: SCIM needs a stable join between source and target. Use an immutable identifier as
externalId(AWS recommends a unique, always present value such as an object ID) and confirm which attribute the identity provider matches on, such asuserName. - Map and scope: rebuild the connector's LDAP filter as assignment or scoping rules in the identity provider. Watch for nested groups: Entra ID reads only immediate members of an assigned group.
- Pilot in parallel, writes off: run SCIM for a pilot group while the LDAP connector still owns everyone else. Never let both write the same users.
- Test the leaver path first: disable a test user at the source and confirm the target suspends the account, ends sessions and revokes tokens. Then test a mover and a rename.
- Cut over by population: move scope from the connector to SCIM in waves; reconcile counts after each wave.
- Decommission: stop the LDAP job, delete its schedule, disable then delete its bind account, and remove its firewall rules.
- Rollback plan: keep the connector configuration exported but disabled for one full review cycle; if SCIM fails, turn SCIM off for the affected scope before turning the connector back on, so the two never run together.
Worked scenario: a manufacturer with 40 SaaS tenants
A manufacturer runs Active Directory, a cloud identity provider for SSO and twelve LDAP sync scripts that each poll an OU nightly and write to a SaaS tenant through its admin API. An audit finds 300 active SaaS accounts for people who left, because three scripts only create and update, two failed for months without alerts, and one treats OU moves as no change. The team inventories the scripts through bind events on the domain controllers, finds that nine of the twelve applications support SCIM, and migrates them in three waves after testing disable, rename and token revocation for each. The remaining three keep their scripts, now with a monitored scheduler, LDAPS, a dedicated read only bind account with a rotated password, and a monthly reconciliation report. Leaver latency for the nine SCIM applications drops from "next working day, if the script runs" to within one provisioning cycle, and the twelve shared bind credentials shrink to three.
Detection and measurement
- Directory side: log binds by sync service accounts and alert on binds from unexpected hosts or outside the job window. See the Active Directory and LDAP Health Check.
- Identity provider side: alert on provisioning jobs in quarantine, failed cycles and SCIM tokens approaching expiry.
- Application side: alert on accounts created outside the provisioning integration and on admin role grants not made through group push.
Metrics:
- Leaver latency: median and 95th percentile time from source disable to target suspension, per application.
- Orphan rate: active target accounts with no matching active source identity, from monthly reconciliation.
- Coverage: share of in-scope SaaS applications provisioned by SCIM versus LDAP connector versus manual.
- Integration credential hygiene: share of SCIM tokens and bind accounts with a named owner and rotated within policy.
- Silent failure count: provisioning runs that failed without an alert reaching an owner.
Common failure patterns
- Create and update only: LDAP scripts written for onboarding that never handle deletes, so leavers stay active in the application.
- Both channels writing: a migration that leaves the LDAP connector running beside SCIM, producing flapping attributes and accounts re-enabled after disable.
- Disable mapped to nothing: directories without a standard inactive attribute, where the connector or the SCIM configuration never maps a disabled state, so only hard deletes take effect.
- Forgotten integration credentials: a bind password or SCIM token that outlives the engineer who set it up and is never rotated. Treat both as non-human identities with owners; see the Joiner-Mover-Leaver Guide for the lifecycle that should cover them.
- Unmonitored expiry: a one year SCIM token that lapses, stopping all creates and disables until someone notices.
- Assuming suspension revokes everything: application API tokens and sessions that survive
activefalse.
Framework mapping
| Framework | Reference | How it applies |
|---|---|---|
| NIST SP 800-53 Rev 5 | AC-2 Account Management; AC-2(3) Disable Accounts; AC-2(4) Automated Audit Actions | Automated, timely disable in every target and logging of account changes |
| NIST SP 800-53 Rev 5 | IA-4 Identifier Management; PS-4 Personnel Termination | Stable identifiers for matching; termination drives access removal |
| NIST SP 800-53 Rev 5 | SC-8 Transmission Confidentiality and Integrity | LDAPS or StartTLS for connectors; TLS for SCIM endpoints |
| NIST CSF 2.0 | PR.AA-01, PR.AA-05 | Identities and credentials managed; access permissions managed and reviewed |
| CIS Controls v8.1 | 5.3 Disable Dormant Accounts; 6.1 Establish an Access Granting Process; 6.2 Establish an Access Revoking Process | Provisioning and revocation automated through one channel |
| ISO/IEC 27001:2022 Annex A | A.5.16 Identity management; A.5.18 Access rights | Lifecycle of identities and timely removal of access rights |
Practitioner checklist
- Inventory every LDAP sync job, agent and script that writes to an application, with its bind account and owner.
- Require LDAPS or StartTLS with certificate validation on every remaining connector.
- Pick one authoritative writer per application and per attribute; never run LDAP sync and SCIM on the same users.
- Use an immutable identifier as the SCIM
externalIdand confirm the matching attribute before cutover. - Test disable, rename and mover changes for each application before go-live, including token and session revocation.
- Prefer OAuth client credentials or token federation over long-lived SCIM bearer tokens where supported, and track expiry.
- Alert on provisioning quarantine, failed cycles and unexpected binds by sync accounts.
- Reconcile target accounts against the source monthly and report leaver latency per application.
- Delete the LDAP job, schedule and bind account when an application moves to SCIM.
Standards and references
- IETF: RFC 4511 Lightweight Directory Access Protocol (LDAP): The Protocol
- IETF: RFC 4533 The LDAP Content Synchronization Operation
- IETF: RFC 7643 System for Cross-domain Identity Management: Core Schema
- IETF: RFC 7644 System for Cross-domain Identity Management: Protocol
- Amazon Web Services: Automatic provisioning in IAM Identity Center
- Google: About Google Cloud Directory Sync
- Microsoft Learn: How application provisioning works in Microsoft Entra ID
- Microsoft Learn: Provisioning users into LDAP directories from Microsoft Entra ID
Related NHI Mgmt Group resources: SCIM Provisioning Guide, LDAP vs SAML vs OIDC, SCIM vs JIT Provisioning, SaaS deprovisioning, Joiner-Mover-Leaver Guide.