instantly-enterprise-rbac

Configure Instantly enterprise SSO, role-based access control, and organization management.Use when implementing SSO integration, configuring role-based permissions,or setting up organization-level controls for Instantly.Trigger with phrases like "instantly SSO", "instantly RBAC","instantly enterprise", "instantly roles", "instantly permissions", "instantly SAML".

⭐939stars🔀114forks📁View on GitHub🕐Updated Jan 11, 2026⬇️1downloads

When & Why to Use This Skill

This Claude skill facilitates the implementation of enterprise-grade security for Instantly integrations. It provides comprehensive configurations for Single Sign-On (SSO) via SAML and OIDC, detailed Role-Based Access Control (RBAC) frameworks, and organization-level management tools. By offering ready-to-use TypeScript snippets for middleware, permission checking, and audit logging, it helps developers and IT administrators secure their outreach infrastructure and maintain compliance.

Use Cases

  • Enterprise SSO Integration: Setting up SAML or OAuth2/OIDC authentication to allow team members to access Instantly using corporate identity providers like Okta or Azure AD.
  • Granular Access Control: Implementing specific roles (Admin, Developer, Viewer, Service) to ensure users only have the permissions necessary for their tasks, such as restricting delete capabilities to administrators.
  • Automated Organization Management: Configuring organization-wide settings including domain whitelisting, mandatory SSO enforcement, and default role assignments for new users.
  • Security Auditing and Compliance: Deploying audit trail logic to track user actions, monitor for suspicious activity, and maintain a verifiable log of resource access for regulatory requirements.
  • Backend Middleware Implementation: Integrating permission-based guards into API endpoints to programmatically protect sensitive Instantly resources from unauthorized access.
nameinstantly-enterprise-rbac
description|
allowed-toolsRead, Write, Edit
version1.0.0
licenseMIT
authorJeremy Longshore <jeremy@intentsolutions.io>

Instantly Enterprise RBAC

Overview

Configure enterprise-grade access control for Instantly integrations.

Prerequisites

  • Instantly Enterprise tier subscription
  • Identity Provider (IdP) with SAML/OIDC support
  • Understanding of role-based access patterns
  • Audit logging infrastructure

Role Definitions

Role Permissions Use Case
Admin Full access Platform administrators
Developer Read/write, no delete Active development
Viewer Read-only Stakeholders, auditors
Service API access only Automated systems

Role Implementation

enum InstantlyRole {
  Admin = 'admin',
  Developer = 'developer',
  Viewer = 'viewer',
  Service = 'service',
}

interface InstantlyPermissions {
  read: boolean;
  write: boolean;
  delete: boolean;
  admin: boolean;
}

const ROLE_PERMISSIONS: Record<InstantlyRole, InstantlyPermissions> = {
  admin: { read: true, write: true, delete: true, admin: true },
  developer: { read: true, write: true, delete: false, admin: false },
  viewer: { read: true, write: false, delete: false, admin: false },
  service: { read: true, write: true, delete: false, admin: false },
};

function checkPermission(
  role: InstantlyRole,
  action: keyof InstantlyPermissions
): boolean {
  return ROLE_PERMISSIONS[role][action];
}

SSO Integration

SAML Configuration

// Instantly SAML setup
const samlConfig = {
  entryPoint: 'https://idp.company.com/saml/sso',
  issuer: 'https://instantly.com/saml/metadata',
  cert: process.env.SAML_CERT,
  callbackUrl: 'https://app.yourcompany.com/auth/instantly/callback',
};

// Map IdP groups to Instantly roles
const groupRoleMapping: Record<string, InstantlyRole> = {
  'Engineering': InstantlyRole.Developer,
  'Platform-Admins': InstantlyRole.Admin,
  'Data-Team': InstantlyRole.Viewer,
};

OAuth2/OIDC Integration

import { OAuth2Client } from '@instantly/sdk';

const oauthClient = new OAuth2Client({
  clientId: process.env.INSTANTLY_OAUTH_CLIENT_ID!,
  clientSecret: process.env.INSTANTLY_OAUTH_CLIENT_SECRET!,
  redirectUri: 'https://app.yourcompany.com/auth/instantly/callback',
  scopes: ['read', 'write'],
});

Organization Management

interface InstantlyOrganization {
  id: string;
  name: string;
  ssoEnabled: boolean;
  enforceSso: boolean;
  allowedDomains: string[];
  defaultRole: InstantlyRole;
}

async function createOrganization(
  config: InstantlyOrganization
): Promise<void> {
  await instantlyClient.organizations.create({
    ...config,
    settings: {
      sso: {
        enabled: config.ssoEnabled,
        enforced: config.enforceSso,
        domains: config.allowedDomains,
      },
    },
  });
}

Access Control Middleware

function requireInstantlyPermission(
  requiredPermission: keyof InstantlyPermissions
) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const user = req.user as { instantlyRole: InstantlyRole };

    if (!checkPermission(user.instantlyRole, requiredPermission)) {
      return res.status(403).json({
        error: 'Forbidden',
        message: `Missing permission: ${requiredPermission}`,
      });
    }

    next();
  };
}

// Usage
app.delete('/instantly/resource/:id',
  requireInstantlyPermission('delete'),
  deleteResourceHandler
);

Audit Trail

interface InstantlyAuditEntry {
  timestamp: Date;
  userId: string;
  role: InstantlyRole;
  action: string;
  resource: string;
  success: boolean;
  ipAddress: string;
}

async function logInstantlyAccess(entry: InstantlyAuditEntry): Promise<void> {
  await auditDb.insert(entry);

  // Alert on suspicious activity
  if (entry.action === 'delete' && !entry.success) {
    await alertOnSuspiciousActivity(entry);
  }
}

Instructions

Step 1: Define Roles

Map organizational roles to Instantly permissions.

Step 2: Configure SSO

Set up SAML or OIDC integration with your IdP.

Step 3: Implement Middleware

Add permission checks to API endpoints.

Step 4: Enable Audit Logging

Track all access for compliance.

Output

  • Role definitions implemented
  • SSO integration configured
  • Permission middleware active
  • Audit trail enabled

Error Handling

Issue Cause Solution
SSO login fails Wrong callback URL Verify IdP config
Permission denied Missing role mapping Update group mappings
Token expired Short TTL Refresh token logic
Audit gaps Async logging failed Check log pipeline

Examples

Quick Permission Check

if (!checkPermission(user.role, 'write')) {
  throw new ForbiddenError('Write permission required');
}

Resources

Next Steps

For major migrations, see instantly-migration-deep-dive.