cd /news/developer-tools/scim-provisioning-deprovisioning-tha… · home › topics › developer-tools › article
[ARTICLE · art-173347] src=dev.to ↗ pub= topic=developer-tools verified=true sentiment=· neutral

SCIM Provisioning & Deprovisioning That Actually Removes Access

A principal software engineer in Karachi published a technical guide on implementing SCIM (RFC 7643/7644) provisioning and deprovisioning for B2B SaaS backends, arguing that deactivation must do more than flip a database flag. The guide specifies that when an identity provider sends active: false or a DELETE, the app must block login, revoke all live sessions, disable API tokens and pending invites, and log the change in a transaction-safe step, with per-tenant hashed bearer tokens scoped to a single tenant.

recommendation

Treat IdP deprovisioning as a full access revocation: kill sessions, tokens and invites in one transaction, and scope each tenant's hashed SCIM bearer token to its own users.

more in playbook: Securing agents and AI tools
by read6 min views8 publishedNov 20, 2026

Here is a scenario I now test on every enterprise SSO integration. An employee leaves a customer company. Their IT team disables the account in the identity provider. The next morning, the ex-employee's laptop is still logged in to your SaaS app, because the session cookie is valid for 30 days and nobody told your app anything. Their personal API token, created months ago for a script, still works too. SSO did its job, which is stopping new logins. It never promised to end existing access.

That gap is why enterprise customers ask for SCIM. SCIM (System for Cross-domain Identity Management, RFC 7643 and RFC 7644) lets the customer's IdP create, update and deactivate users in your app automatically. But a SCIM endpoint that flips a database flag and does nothing else gives the customer a false sense of safety. This post is about the part that matters: deprovisioning that actually removes access.

I wrote this with help from AI tools and checked the details against RFC 7644 and the Okta and Microsoft Entra SCIM provisioning documentation. I am a Principal Software Engineer in Karachi with 9+ years building Laravel, Node and .NET SaaS backends, and everything here is defensive configuration of your own application.

📚 Series Navigation — Enterprise SSO & Identity for B2B SaaS

Part 1: Enterprise SSO Readiness: SAML vs OIDC for B2B SaaS Part 2: Validating SAML Responses: Signatures, Audience & Clock Skew Part 3 (This Post): SCIM Provisioning & Deprovisioning That Actually Removes Access Part 4: Multi-Tenant Login Routing: Domain Discovery & Enforced SSO Part 5: Just-in-Time Provisioning & Role Mapping From IdP Groups Part 6: Break-Glass Accounts & SSO Audit Logs Related earlier posts: Session Lifecycle Hardening: Rotation, Timeouts & Server-Side Revocation · Webhooks That Stopped Arriving: Gap Detection & Reconciliation

Direct answer: When the IdP sends active: false or a DELETE for a user, your app must block login, revoke every live session, disable API tokens and pending invites, and log the change, all in one transaction-safe step. Flipping a flag without killing existing sessions and tokens leaves the ex-employee with working access.

A full SCIM server can be large. For user lifecycle, the IdPs mostly call a small set of endpoints under a tenant-specific base URL such as https://app.example.com/scim/v2/:

Operation HTTP call Sent by IdP when What your app must do
Find user GET /Users?filter=userName eq "a@corp.com" Before create, to avoid duplicates Return a ListResponse, empty if none
Create POST /Users User assigned to your app Create or link the user, return 201 with id
Update PATCH /Users/{id} Name, email or attribute change Apply ops, return 200 with the resource
Deactivate PATCH /Users/{id} withactive: false User unassigned or disabled Block login and revoke all access
Delete DELETE /Users/{id} Some IdPs on hard removal Same as deactivate, then 204
Groups /Groups endpoints Group push enabled Covered in Part 5 with role mapping

Okta and Entra ID both commonly deactivate with a PATCH rather than a DELETE, so the PATCH path is the one you must get right.

Each customer tenant gets its own long random bearer token for SCIM, stored hashed, shown once, and rotatable. Never reuse one global token across tenants: a token must only be able to touch its own tenant's users.

// app/Http/Middleware/ScimAuth.php
public function handle(Request $request, Closure $next)
{
    $token = $request->bearerToken();
    $conn = $token ? ScimConnection::where('token_hash', hash('sha256', $token))
                                   ->where('enabled', true)->first() : null;

    if (! $conn) {
        return response()->json([
            'schemas' => ['urn:ietf:params:scim:api:messages:2.0:Error'],
            'status'  => '401', 'detail' => 'Invalid SCIM token',
        ], 401);
    }
    app()->instance('scim.tenant', $conn->tenant_id);   // scope every query to this tenant
    return $next($request);
}

A typical deactivation request from an IdP looks like this:

{
  "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
  "Operations": [
    { "op": "replace", "value": { "active": false } }
  ]
}

Some IdPs send "path": "active", "value": false instead, and some send the value as the string "False". Normalize all of these. Then the important part: deactivation calls a single service that removes every kind of access.

final class DeprovisionUser
{
    public function handle(User $user, string $source): void
    {
        DB::transaction(function () use ($user, $source) {
            $user->forceFill(['active' => false, 'deactivated_at' => now()])->save();

            // 1. Kill every live session (database or Redis session driver)
            DB::table('sessions')->where('user_id', $user->id)->delete();

            // 2. Revoke API tokens and OAuth grants
            $user->tokens()->delete();                       // Sanctum personal access tokens
            OAuthRefreshToken::where('user_id', $user->id)->update(['revoked' => true]);

            // 3. Cancel invites they sent and pending ones addressed to them
            Invitation::where('invited_by', $user->id)->whereNull('accepted_at')->delete();

            // 4. Record it
            AuditLog::record('user.deprovisioned', $user, ['source' => $source]);
        });

        event(new UserDeprovisioned($user));  // websockets disconnect, cache bust
    }
}

Because a refresh token can mint new access tokens, revoking only access tokens is not enough. And because short-lived JWT access tokens cannot be recalled, keep their lifetime short (5 to 15 minutes) and check active when refreshing. Part 2 of my session series covers server-side revocation in more depth.

IdPs retry. They may send the same deactivation twice, or a create for a user who already exists. Your endpoints should converge on the same state, not error out:

POST /Users for an existing userName in the same tenant either links to it or returns 409 uniqueness, depending on what the IdP expects; Okta and Entra docs both describe the filter-then-create flow, so support the GET filter correctly first.DELETE of an unknown id returns 404, not 500. Match users on the stable externalId the IdP sends where possible, not on email, because emails change when people marry or the company renames its domain.

Deprovisioning fails quietly through paths that do not go through SSO at all. I check each of these during review:

Write a test that proves access is actually gone, not just that the flag changed:

curl -s -X PATCH https://app.example.test/scim/v2/Users/$USER_ID \
  -H "Authorization: Bearer $SCIM_TOKEN" -H "Content-Type: application/scim+json" \
  -d '{"schemas":["urn:ietf:params:scim:api:messages:2.0:PatchOp"],"Operations":[{"op":"replace","value":{"active":false}}]}'
curl -s -o /dev/null -w "%{http_code}\n" -b "session=$COOKIE" https://app.example.test/dashboard
curl -s -o /dev/null -w "%{http_code}\n" -H "Authorization: Bearer $API_TOKEN" https://app.example.test/api/me

When I debug a failing provisioning run, I paste the IdP's request body into the JSON Formatter to spot the exact shape of the PATCH, and use the HTTP Status Checker to confirm the SCIM base URL answers with the right status and no redirect, since some IdPs refuse to follow redirects.

active: false is handled in all common shapes (value object, path, string)active flag No. Single logout depends on the user's browser and is unreliable across apps. It also does nothing for API tokens. SCIM is a server-to-server signal you can act on.

Usually not. Deactivate the account and keep its records, because the customer still owns the projects, invoices or tickets the person created. Offer deletion as a separate, explicit admin action.

Give the tenant admin a clear "deactivate user" button that calls the same DeprovisionUser service, so the result is identical whatever the trigger.

Your side should act immediately when the request arrives. The IdP's own sync interval is outside your control, which is another reason to keep access tokens short-lived.

Start with Users and the deactivation path. Add Groups when customers ask for role mapping, which Part 5 covers.

A PATCH with active: true should restore login only. Do not restore old sessions or tokens; the user signs in fresh and creates new ones.

Next in this series, Part 4 covers multi-tenant login routing: discovering a user's tenant from their email domain and enforcing SSO for it.

── more in #developer-tools 4 stories · sorted by recency
── more on @okta 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/scim-provisioning-de…] indexed:0 read:6min 2026-11-20 · —