A new account executive starts on Monday. On Friday afternoon, HR marks her hire as complete in the HRIS, IT adds her to the Sales group in Okta, and within minutes she has accounts in Slack, Google Workspace, Zoom and Salesforce. Nobody typed her name into any of them. That part is SCIM.
On Monday morning she still can’t open the contract tool, because her company’s plan for it doesn’t include SCIM. Her Salesforce account exists but has the wrong license, so she can’t see the forecast. Her laptop was ordered on Thursday. Payroll found out about her from an email. None of that is SCIM’s job, and that gap is where most onboarding time goes.
The short answer. SCIM (System for Cross-domain Identity Management) is an open standard for creating, updating and deactivating user accounts across apps automatically. Your identity provider, such as Okta, Microsoft Entra ID or JumpCloud, uses an app’s SCIM API to add a user when they’re assigned the app, change their details when they change, and set the account to inactive when they leave. SCIM covers users and groups in apps that support it. It does not cover apps without a SCIM endpoint, licenses and roles each app defines its own way, or the work around identity: equipment, tickets, payroll and handing over a leaver’s data.
What is SCIM?
SCIM is a pair of IETF standards, both published in September 2015:
- RFC 7643, the core schema. It defines what a user and a group look like in JSON: userName, name, emails, an active flag, group memberships and so on. An Enterprise User extension adds fields companies need, including employeeNumber, costCenter, department and manager.
- RFC 7644, the protocol. It defines an HTTP API for those objects. An app that supports SCIM exposes endpoints such as
/Usersand/Groups, and accepts the standard methods: POST to create, GET to read, PUT and PATCH to update, DELETE to remove.
A third document, RFC 7642, sets out the definitions and use cases. When people say “SCIM” today they almost always mean SCIM 2.0.
The point of the standard is that an identity provider can manage accounts in hundreds of apps without a custom integration for each one. The app builds one SCIM endpoint, and every identity provider that speaks SCIM can use it.
How SCIM provisioning works
Take a company running Microsoft Entra ID (formerly Azure Active Directory) with SCIM set up for its project management tool. In SCIM terms, Entra ID is the client and the app is the service provider.
- Someone is assigned the app. IT adds a new hire to a group that’s assigned to the project tool.
- The identity provider looks for an existing account. It queries the app’s
/Usersendpoint for a match on a chosen attribute, usually the email or user principal name. - It creates or updates the account. No match means a POST to
/Userswith the mapped attributes. A match means an update. The identity provider stores the app’s id for that user and uses it for every later change. - Changes flow on their own. A new last name, a new department or a new manager in the directory becomes a PATCH to the app.
- Leaving deactivates the account. When the user is unassigned or disabled, the identity provider sends an update that sets
activeto false. The person can no longer sign in, and the account and its data stay in place.
The main identity providers all work this way, with differences worth knowing:
- Okta creates and updates users, pushes groups, and deprovisions by setting
active=false. Okta’s developer documentation says it does not send a request to delete the user in the app. - Microsoft Entra ID runs provisioning in cycles: a first full cycle, then incremental cycles at an interval set for each app, so a change can wait for the next cycle. It disables users with
activeset to false and sends a DELETE when a user is permanently deleted, which by default happens 30 days after a soft delete. - JumpCloud provisions through Identity Management connectors built on SCIM, and notes that not every app supports all provisioning actions.
- OneLogin and Google Workspace also provision to supported apps. Google Workspace’s autoprovisioning keeps account changes in step with each app it supports, and covers active, suspended and deleted users.
SCIM vs SAML and SSO
SAML and SCIM solve different halves of the same problem.
SAML 2.0 (and its newer counterpart, OpenID Connect) is about sign-in. It lets a person log in to an app with their company identity, so the identity provider checks the password and multi-factor prompt instead of the app. That’s single sign-on, or SSO.
SCIM is about the account behind that sign-in. It creates the account before the first login, keeps its details current, and deactivates it when the person leaves.
The two fail differently. With SSO and no SCIM, someone usually has to create accounts by hand, or the app creates them on first login and never learns when the person leaves. Disabling the user in the identity provider blocks new SSO sign-ins, but an existing session, a local password or an API token can outlast it. With SCIM, the account itself is switched off. Most companies want both, and many apps sell them together.
What SCIM handles well
Where an app has a good SCIM endpoint, SCIM is the right tool, and there’s no reason to rebuild it:
- Creating users with name, email, username and the directory fields the app accepts.
- Updating users when their details change in the directory: name changes, department, title, manager.
- Deactivating users the moment they lose the assignment, without deleting their data.
- Managing groups, so membership in the directory decides membership in the app.
For a company with 50 SaaS apps that all support SCIM, this covers a large share of joiner, mover and leaver work. The trouble is that very few companies have 50 apps that all support SCIM.
What SCIM doesn’t cover
Apps with no SCIM endpoint
Many apps never built one. Smaller vendors, internal tools, older systems and industry-specific software often have a user API but no SCIM endpoint, and some have only an admin screen. An identity provider can’t provision an app that doesn’t speak SCIM, so those accounts go back to tickets and hand entry.
SCIM on the top plan only
Plenty of apps support SCIM but put it on their enterprise tier, alongside SAML. If your company buys the mid-tier plan of a tool used by 40 people, the SCIM endpoint exists and you can’t use it. The choice is an upgrade for one feature or manual provisioning.
Roles and licenses each app defines its own way
RFC 7643 includes roles and entitlements attributes, but it says plainly that no vocabulary or syntax is specified for them. Every app decides what a role means, and many SCIM endpoints only handle users and groups. In practice that leaves out:
- Which license or seat type someone gets: a full Salesforce license or a platform one, an editor seat or a viewer seat.
- App-specific permissions such as a permission set, a project role or an approval limit.
- Which records, queues or workspaces the person can see.
Groups can stand in for some of this when the app maps groups to roles. When it doesn’t, someone sets the role by hand after SCIM creates the account.
The work around the account
SCIM manages accounts. Onboarding and offboarding are much bigger than accounts:
- The trigger. SCIM starts when someone is assigned an app in the identity provider. The real start is the hire record in the HRIS, with a start date that can move.
- Equipment. A laptop ordered on day one arrives in week three, so it has to be ordered when the offer is signed.
- IT tickets. Tasks that can’t be automated still need a ticket in the service desk, created and tracked.
- Payroll and benefits. The hire, and every change after it, has to reach payroll before the cut-off.
- Data on offboarding. Before an account is switched off, the leaver’s files, calendar, open deals and tickets need a new owner. SCIM deactivation does none of that, and a transfer after the mailbox is disabled is a support ticket, and sometimes lost data. The employee offboarding process covers the rest.
How teams close the gap
Ten days to onboard one person was normal at one fast-growing consumer fintech, with HR, IT, recruiting and procurement copying profiles between systems and a five-person team building and shipping computers. It was hiring hundreds of people a month, and PowerShell scripts had stopped keeping up.
The company made ADP its single source of truth and connected it to JumpCloud, its directory, so a hire in ADP starts provisioning. SCIM handles the apps that support it. For everything else, the same workflow calls each app’s API. As their Director of Support put it: “Tray lets us automatically create access for applications that either don’t support SCIM (System for Cross-domain Identity Management) or don’t integrate well with JumpCloud.” The workflow also connects Greenhouse, Monday and their Freshservice service desk for the tickets and requests around each hire.
Onboarding went from about 10 days to four or five minutes, at up to 100 new hires a week, while the company grew from about 800 to 3,000 people in 18 months. The full story is in the fintech leader case study.
The pattern generalizes. Teams that close the SCIM gap tend to build one onboarding workflow that does five things:
- Starts from the HRIS record, with the start date as the deadline, not from a ticket.
- Lets the identity provider run SCIM for every app that supports it. Assigning the right groups is the workflow’s job, and SCIM does the rest.
- Calls each remaining app’s user API directly to create the account, set the license and assign the role SCIM can’t express.
- Opens tickets and orders equipment for the steps that need a person, so they’re tracked rather than remembered.
- Records evidence for each grant: which system, which access, when, and on whose authority, so an access review is a query.
Here is what that looks like for one new account executive with a Monday start. HR saves the hire in the HRIS on the Wednesday before, and the workflow starts:
| Step | System | How it happens |
|---|---|---|
| Hire saved | HRIS | Starts the workflow, with Monday as the deadline |
| Directory account and groups | Identity provider | The workflow creates the user and adds them to “Sales” and “All staff” |
| Email, chat and CRM accounts | Apps that support SCIM | The identity provider creates each account through SCIM, because the groups are assigned |
| CRM role and territory | CRM | The workflow sets them through the CRM’s API. SCIM created the user, but not the role |
| Sales engagement seat | App without SCIM on your plan | The workflow creates the user through the app’s API and assigns a license |
| Laptop | IT service desk | The workflow opens a ticket so the laptop ships before Monday |
| Evidence | Audit log | The workflow records each grant: which system, which access, when, and why |
Only one of those rows is SCIM, and the identity provider runs it once the groups are set. The other six are why onboarding still takes days without a workflow around it.
Offboarding runs the same workflow in reverse: transfer ownership first, then deactivate through SCIM and each app’s API, revoke tokens, recover the device and check that the access is actually gone. The guides to building onboarding provisioning and building offboarding deprovisioning have the prompts for each step, and employee lifecycle automation covers the stages between hire and exit.
Where Tray.ai fits
Tray.ai doesn’t replace your identity provider or SCIM. It runs the workflow around them: triggered from the HRIS, assigning groups in Okta or JumpCloud so SCIM can do its part, and calling the APIs of the apps SCIM doesn’t reach. Tray.ai connects to 12,000+ apps, databases, APIs, and services. Tickets, laptop orders, payroll updates and the evidence log run in the same workflow, so IT sees one run per hire instead of a checklist. If you’re comparing this with building lifecycle flows inside your identity provider, see Tray.ai vs Okta Workflows.
Sources
All read November 14, 2026.
- IETF, RFC 7643: SCIM Core Schema
- IETF, RFC 7644: SCIM Protocol
- Microsoft Learn, How application provisioning works in Microsoft Entra ID
- Okta Developer, Understanding SCIM
- JumpCloud, Get started: SCIM connectors
- Google Workspace Admin Help, Configure 15Five user provisioning (one of Google’s per-app provisioning guides)