SCIM Management Reference

Create SCIM Connection

Creates a SCIM connection and returns a SCIM API key for your users to provide to their IdP.

Arguments

customerId string required

The ID of the customer/organization that the SCIM connection is for

displayName string

A display name for the SCIM connection

scimApiKeyExpiration number

UNIX timestamp when the API key expires (omit for no expiration)

customMapping ScimUserMappingConfig

Custom property mapping for this SCIM connection

Successful Response

connectionId string

The unique identifier for the created SCIM connection

scimApiKey string

The API key to provide to the IdP for SCIM provisioning

Error Types

InvalidFields

One or more fields have invalid values

ScimConnectionForCustomerIdAlreadyExists

A SCIM connection already exists for this customer ID

UnexpectedError

An unexpected error occurred during the operation

const auth = createClient({ url, integrationKey });

const result = await auth.scim.management.createScimConnection({
  customerId: "106ce124-1082-4d72-835d-dd1b2172f2fe",
  displayName: "Example SCIM Connection",
  scimApiKeyExpiration: 1760232804,
  customMapping: {
    userSchema: [
      {
        outputField: "manager",
        inputPath: "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
        fallbackInputPaths: [
          "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
        ],
        propertyType: {
          dataType: "String"
        },
        displayName: "My Manager",
        description: "Your manager's name",
        warnIfMissing: true,
        defaultValue: "manager@acmeinc.com"
      }
    ]
  }
});

if (result.ok) {
  console.log("SCIM connection created successfully");
  console.log(`Connection ID: ${result.data.connectionId}`);
  console.log(`API Key: ${result.data.scimApiKey}`);
} else {
  console.log(`Error: ${result.error}`);
  // Check result.error.type to handle specific errors
}

client = create_client(url=url, integration_key=integration_key)

result = await client.scim.management.create_scim_connection(
    customer_id="106ce124-1082-4d72-835d-dd1b2172f2fe",
    display_name="Example SCIM Connection",
    scim_api_key_expiration=1760232804,
    custom_mapping=ScimUserMappingConfig(
        user_schema=[
            ScimUserMappingFieldDefinition(
                output_field="manager",
                input_path="urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                fallback_input_paths=[
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                ],
                property_type=PropertyTypeString(),
                display_name="My Manager",
                description="Your manager's name",
                warn_if_missing=True,
                default_value="manager@acmeinc.com"
            )
        ]
    )
)

if is_ok(result):
    print("SCIM connection created successfully")
    print(f"Connection ID: {result.data.connection_id}")
    print(f"API Key: {result.data.scim_api_key}")
else:
    print(f"Error: {result.error.type}")
    # Check result.error.type to handle specific errors

client, err := byo.NewClient(url, integrationKey)
if err != nil {
    log.Fatal(err)
}

result, err := client.Scim.Management.CreateScimConnection(ctx, byo.CreateScimConnectionCommand{
    CustomerID:           "106ce124-1082-4d72-835d-dd1b2172f2fe",
    DisplayName:          byo.String("Example SCIM Connection"),
    ScimAPIKeyExpiration: byo.Int(1760232804),
    CustomMapping: &byo.ScimUserMappingConfig{
        UserSchema: []byo.ScimUserMappingFieldDefinition{
            {
                OutputField:        "manager",
                InputPath:          "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                FallbackInputPaths: []string{"urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"},
                PropertyType:       &byo.PropertyTypeString{},
                DisplayName:        "My Manager",
                Description:        byo.String("Your manager's name"),
                WarnIfMissing:      true,
            },
        },
    },
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(result.ScimAPIKey)

PropelAuthClient client = PropelAuthClient.create(url, integrationKey);

CreateScimConnectionCommand command = CreateScimConnectionCommand.builder()
    .customerId("106ce124-1082-4d72-835d-dd1b2172f2fe")
    .displayName("Example SCIM Connection")
    .scimApiKeyExpiration(1760232804)
    .customMapping(ScimUserMappingConfig.builder()
        .userSchema(Arrays.asList(
            ScimUserMappingFieldDefinition.builder()
                .outputField("manager")
                .inputPath("urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager")
                .fallbackInputPaths(Arrays.asList(
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                ))
                .propertyType(new PropertyType.String())
                .displayName("My Manager")
                .description("Your manager's name")
                .warnIfMissing(true)
                .defaultValue(JsonValue.of("manager@acmeinc.com"))
                .build()
        ))
        .build())
    .build();

try {
    CreateScimConnectionResponse response = client.scim.management.createScimConnection(command);
    System.out.println("SCIM connection created successfully");
    System.out.println("Connection ID: " + response.getConnectionId());
    System.out.println("API Key: " + response.getScimApiKey());
} catch (CreateScimConnectionException.InvalidFields e) {
    System.out.println("Invalid fields: " + e.getDetails());
} catch (CreateScimConnectionException.ScimConnectionForCustomerIdAlreadyExists e) {
    System.out.println("SCIM connection already exists for this customer");
} catch (CreateScimConnectionException e) {
    System.out.println("Error: " + e.getMessage());
}

var client = new PropelAuthClient(new PropelAuthOptions { Url = url, IntegrationKey = integrationKey });

var command = new CreateScimConnectionCommand
{
    CustomerId = "106ce124-1082-4d72-835d-dd1b2172f2fe",
    DisplayName = "Example SCIM Connection",
    ScimApiKeyExpiration = 1760232804,
    CustomMapping = new ScimUserMappingConfig
    {
        UserSchema = new List<ScimUserMappingFieldDefinition>
        {
            new ScimUserMappingFieldDefinition
            {
                OutputField = "manager",
                InputPath = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                FallbackInputPaths = new List<string>
                {
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                },
                PropertyType = new PropertyTypeString(),
                DisplayName = "My Manager",
                Description = "Your manager's name",
                WarnIfMissing = true,
                DefaultValue = JsonSerializer.SerializeToElement("manager@acmeinc.com")
            }
        }
    }
};

try
{
    var response = await client.Scim.Management.CreateScimConnectionAsync(command);
    Console.WriteLine("SCIM connection created successfully");
    Console.WriteLine($"Connection ID: {response.ConnectionId}");
    Console.WriteLine($"API Key: {response.ScimApiKey}");
}
catch (CreateScimConnectionException.InvalidFields ex)
{
    Console.WriteLine($"Invalid fields: {ex.Details}");
}
catch (CreateScimConnectionException.ScimConnectionForCustomerIdAlreadyExists)
{
    Console.WriteLine("SCIM connection already exists for this customer");
}
catch (CreateScimConnectionException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Response

{
  ok: true,
  data: {
    connectionId: "s8vmjNLuieN1feLOya0mf3",
    scimApiKey: "scim_s8vmjNLuieN1feLOya0mf3_FS5RYqqSeZBj7h5RfGE9V7"
  }
}

Result(
    data=CreateScimConnectionResponse(
        connection_id="s8vmjNLuieN1feLOya0mf3",
        scim_api_key="scim_s8vmjNLuieN1feLOya0mf3_FS5RYqqSeZBj7h5RfGE9V7"
    )
)

byo.CreateScimConnectionResponse{
    ConnectionID: "s8vmjNLuieN1feLOya0mf3",
    ScimAPIKey:   "scim_s8vmjNLuieN1feLOya0mf3_FS5RYqqSeZBj7h5RfGE9V7",
}

CreateScimConnectionResponse(
    connectionId="s8vmjNLuieN1feLOya0mf3",
    scimApiKey="scim_s8vmjNLuieN1feLOya0mf3_FS5RYqqSeZBj7h5RfGE9V7"
)

CreateScimConnectionResponse
{
    ConnectionId = "s8vmjNLuieN1feLOya0mf3",
    ScimApiKey = "scim_s8vmjNLuieN1feLOya0mf3_FS5RYqqSeZBj7h5RfGE9V7"
}

Fetch SCIM Connection

Retrieves SCIM connection details by connection ID or customer ID.

Arguments

scimConnectionId string

The ID of the SCIM connection

customerId string

The customer ID (alternative to scimConnectionId)

Successful Response

connectionId string

The SCIM connection ID

customerId string

The associated customer ID

displayName string | null

The display name of the connection

scimApiKeyValidUntil number | null

UNIX timestamp when the API key expires (null if no expiration)

userMapping ScimUserMappingConfig

The user property mapping configuration

Error Types

ScimConnectionNotFound

The provided SCIM connection ID or customer ID could not be found

UnexpectedError

An unexpected error occurred during the operation

const auth = createClient({ url, integrationKey });

const result = await auth.scim.management.fetchScimConnection({
  scimConnectionId: "s8vmjNLuieN1feLOya0mf3"
});

if (result.ok) {
  console.log("SCIM connection fetched successfully");
  console.log(`Connection ID: ${result.data.connectionId}`);
  console.log(`Customer ID: ${result.data.customerId}`);
  console.log(`Display Name: ${result.data.displayName}`);
} else {
  console.log(`Error: ${result.error}`);
  // Check result.error.type to handle specific errors
}

client = create_client(url=url, integration_key=integration_key)

result = await client.scim.management.fetch_scim_connection(
    scim_connection_id="s8vmjNLuieN1feLOya0mf3"
)

if is_ok(result):
    print("SCIM connection fetched successfully")
    print(f"Connection ID: {result.data.connection_id}")
    print(f"Customer ID: {result.data.customer_id}")
    print(f"Display Name: {result.data.display_name}")
else:
    print(f"Error: {result.error.type}")
    # Check result.error.type to handle specific errors

client, err := byo.NewClient(url, integrationKey)
if err != nil {
    log.Fatal(err)
}

result, err := client.Scim.Management.FetchScimConnection(ctx, &byo.FetchScimConnectionCommandScimConnectionID{
    ScimConnectionID: "s8vmjNLuieN1feLOya0mf3",
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(result.CustomerID)

PropelAuthClient client = PropelAuthClient.create(url, integrationKey);

FetchScimConnectionCommand command = FetchScimConnectionCommand.scimConnectionId.builder()
    .scimConnectionId("s8vmjNLuieN1feLOya0mf3")
    .build();

try {
    FetchScimConnectionResponse response = client.scim.management.fetchScimConnection(command);
    System.out.println("SCIM connection fetched successfully");
    System.out.println("Connection ID: " + response.getConnectionId());
    System.out.println("Customer ID: " + response.getCustomerId());
    System.out.println("Display Name: " + response.getDisplayName());
} catch (FetchScimConnectionException.ScimConnectionNotFound e) {
    System.out.println("SCIM connection not found");
} catch (FetchScimConnectionException e) {
    System.out.println("Error: " + e.getMessage());
}

var client = new PropelAuthClient(new PropelAuthOptions { Url = url, IntegrationKey = integrationKey });

try
{
    var response = await client.Scim.Management.FetchScimConnectionByScimConnectionIdAsync("s8vmjNLuieN1feLOya0mf3");
    Console.WriteLine("SCIM connection fetched successfully");
    Console.WriteLine($"Connection ID: {response.ConnectionId}");
    Console.WriteLine($"Customer ID: {response.CustomerId}");
    Console.WriteLine($"Display Name: {response.DisplayName}");
}
catch (FetchScimConnectionException.ScimConnectionNotFound)
{
    Console.WriteLine("SCIM connection not found");
}
catch (FetchScimConnectionException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Response

{
  ok: true,
  data: {
    connectionId: "s8vmjNLuieN1feLOya0mf3",
    customerId: "106ce124-1082-4d72-835d-dd1b2172f2fe",
    displayName: "Example Connection",
    scimApiKeyValidUntil: 1760232804,
    userMapping: {
      userSchema: [
        {
          outputField: "manager",
          inputPath: "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
          fallbackInputPaths: [
            "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
          ],
          propertyType: {
            dataType: "String"
          },
          displayName: "My Manager",
          description: "Your manager's name",
          warnIfMissing: true,
          defaultValue: "manager@acmeinc.com"
        }
      ]
    }
  }
}

Result(
    data=FetchScimConnectionResponse(
        connection_id="s8vmjNLuieN1feLOya0mf3",
        customer_id="106ce124-1082-4d72-835d-dd1b2172f2fe",
        display_name="Example Connection",
        scim_api_key_valid_until=1760232804,
        user_mapping=ScimUserMappingConfig(
            user_schema=[
                ScimUserMappingFieldDefinition(
                    output_field="manager",
                    input_path="urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                    fallback_input_paths=[
                        "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                    ],
                    property_type=PropertyTypeString(),
                    display_name="My Manager",
                    description="Your manager's name",
                    warn_if_missing=True,
                    default_value="manager@acmeinc.com"
                )
            ]
        )
    )
)

byo.FetchScimConnectionResponse{
    ConnectionID:         "s8vmjNLuieN1feLOya0mf3",
    CustomerID:           "106ce124-1082-4d72-835d-dd1b2172f2fe",
    DisplayName:          byo.String("Example Connection"),
    ScimAPIKeyValidUntil: byo.Int(1760232804),
    UserMapping: byo.ScimUserMappingConfig{
        UserSchema: []byo.ScimUserMappingFieldDefinition{
            {
                OutputField:        "manager",
                InputPath:          "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                FallbackInputPaths: []string{"urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"},
                PropertyType:       &byo.PropertyTypeString{},
                DisplayName:        "My Manager",
                Description:        byo.String("Your manager's name"),
                WarnIfMissing:      true,
            },
        },
    },
}

FetchScimConnectionResponse(
    connectionId="s8vmjNLuieN1feLOya0mf3",
    customerId="106ce124-1082-4d72-835d-dd1b2172f2fe",
    displayName="Example Connection",
    scimApiKeyValidUntil=1760232804,
    userMapping=ScimUserMappingConfig(
        userSchema=[
            ScimUserMappingFieldDefinition(
                outputField="manager",
                inputPath="urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                fallbackInputPaths=[
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                ],
                propertyType=PropertyType.String(),
                displayName="My Manager",
                description="Your manager's name",
                warnIfMissing=true,
                defaultValue="manager@acmeinc.com"
            )
        ]
    )
)

FetchScimConnectionResponse
{
    ConnectionId = "s8vmjNLuieN1feLOya0mf3",
    CustomerId = "106ce124-1082-4d72-835d-dd1b2172f2fe",
    DisplayName = "Example Connection",
    ScimApiKeyValidUntil = 1760232804,
    UserMapping = ScimUserMappingConfig
    {
        UserSchema = [
            ScimUserMappingFieldDefinition
            {
                OutputField = "manager",
                InputPath = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                FallbackInputPaths = [
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                ],
                PropertyType = PropertyType.String(),
                DisplayName = "My Manager",
                Description = "Your manager's name",
                WarnIfMissing = true,
                DefaultValue = "manager@acmeinc.com"
            }
        ]
    }
}

Patch SCIM Connection

Updates an existing SCIM connection configuration.

Arguments

scimConnectionId string

The ID of the SCIM connection

customerId string

The customer ID (alternative to scimConnectionId)

displayName string

New display name for the SCIM connection

scimApiKeyExpiration number

UNIX timestamp when the API key should expire

customMapping ScimUserMappingConfig

Custom property mapping for this SCIM connection

Successful Response

Returns an empty response on success

Error Types

ScimConnectionNotFound

The provided SCIM connection ID could not be found

DisplayNameInvalid

The provided display name is not valid

UnexpectedError

An unexpected error occurred during the operation

const auth = createClient({ url, integrationKey });

const result = await auth.scim.management.patchScimConnection({
  scimConnectionId: "s8vmjNLuieN1feLOya0mf3",
  displayName: "Updated SCIM Connection",
  scimApiKeyExpiration: 1760232804,
  customMapping: {
    userSchema: [
      {
        outputField: "manager",
        inputPath: "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
        fallbackInputPaths: [
          "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
        ],
        propertyType: {
          dataType: "String"
        },
        displayName: "My Manager",
        description: "Your manager's name",
        warnIfMissing: true,
        defaultValue: "manager@acmeinc.com"
      }
    ]
  }
});

if (result.ok) {
  console.log("SCIM connection updated successfully");
} else {
  console.log(`Error: ${result.error}`);
  // Check result.error.type to handle specific errors
}

client = create_client(url=url, integration_key=integration_key)

result = await client.scim.management.patch_scim_connection(
    scim_connection_id="s8vmjNLuieN1feLOya0mf3",
    display_name="Updated SCIM Connection",
    scim_api_key_expiration=1760232804,
    custom_mapping={
        "userSchema": [
            {
                "outputField": "manager",
                "inputPath": "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                "fallbackInputPaths": [
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                ],
                "propertyType": {
                    "dataType": "String"
                },
                "displayName": "My Manager",
                "description": "Your manager's name",
                "warnIfMissing": True,
                "defaultValue": "manager@acmeinc.com"
            }
        ]
    }
)

if is_ok(result):
    print("SCIM connection updated successfully")
else:
    print(f"Error: {result.error}")
    # Check result.error.type to handle specific errors

client, err := byo.NewClient(url, integrationKey)
if err != nil {
    log.Fatal(err)
}

_, err = client.Scim.Management.PatchScimConnection(ctx, &byo.PatchScimConnectionCommandScimConnectionID{
    ScimConnectionID:     "s8vmjNLuieN1feLOya0mf3",
    DisplayName:          byo.String("Updated SCIM Connection"),
    ScimAPIKeyExpiration: byo.Int(1760232804),
    CustomMapping: &byo.ScimUserMappingConfig{
        UserSchema: []byo.ScimUserMappingFieldDefinition{
            {
                OutputField:        "manager",
                InputPath:          "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                FallbackInputPaths: []string{"urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"},
                PropertyType:       &byo.PropertyTypeString{},
                DisplayName:        "My Manager",
                Description:        byo.String("Your manager's name"),
                WarnIfMissing:      true,
            },
        },
    },
})
if err != nil {
    log.Fatal(err)
}

PropelAuthClient client = PropelAuthClient.create(url, integrationKey);

PatchScimConnectionCommand command = PatchScimConnectionCommand.scimConnectionId.builder()
    .scimConnectionId("s8vmjNLuieN1feLOya0mf3")
    .displayName("Updated SCIM Connection")
    .scimApiKeyExpiration(1760232804)
    .customMapping(ScimUserMappingConfig.builder()
        .userSchema(Arrays.asList(
            ScimUserMappingFieldDefinition.builder()
                .outputField("manager")
                .inputPath("urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager")
                .fallbackInputPaths(Arrays.asList(
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                ))
                .propertyType(new PropertyType.String())
                .displayName("My Manager")
                .description("Your manager's name")
                .warnIfMissing(true)
                .defaultValue(JsonValue.of("manager@acmeinc.com"))
                .build()
        ))
        .build())
    .build();

try {
    PatchScimConnectionResponse response = client.scim.management.patchScimConnection(command);
    System.out.println("SCIM connection updated successfully");
} catch (PatchScimConnectionException.ScimConnectionNotFound e) {
    System.out.println("SCIM connection not found");
} catch (PatchScimConnectionException.DisplayNameInvalid e) {
    System.out.println("Display name invalid: " + e.getDetails());
} catch (PatchScimConnectionException e) {
    System.out.println("Error: " + e.getMessage());
}

var client = new PropelAuthClient(new PropelAuthOptions { Url = url, IntegrationKey = integrationKey });

var response = await client.Scim.Management.PatchScimConnectionByScimConnectionIdAsync(
    scimConnectionId: "s8vmjNLuieN1feLOya0mf3",
    displayName: "Updated SCIM Connection",
    scimApiKeyExpiration: 1760232804,
    customMapping: new ScimUserMappingConfig
    {
        UserSchema = new List<ScimUserMappingFieldDefinition>
        {
            new ScimUserMappingFieldDefinition
            {
                OutputField = "manager",
                InputPath = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
                FallbackInputPaths = new List<string>
                {
                    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:managerId"
                },
                PropertyType = new PropertyTypeString(),
                DisplayName = "My Manager",
                Description = "Your manager's name",
                WarnIfMissing = true,
                DefaultValue = JsonSerializer.SerializeToElement("manager@acmeinc.com")
            }
        }
    }
);

Console.WriteLine("SCIM connection updated successfully");

Response

{
  ok: true,
  data: {}
}

Result(
    ok=True,
    data=PatchScimConnectionResponse()
)

byo.PatchScimConnectionResponse{}

PatchScimConnectionResponse()

PatchScimConnectionResponse
{
}

Reset SCIM Connection API Key

Invalidates a SCIM connection's API key and generates a new one.

Arguments

scimConnectionId string

The ID of the SCIM connection

customerId string

The customer ID (alternative to scimConnectionId)

scimApiKeyExpiration number

UNIX timestamp when the new API key expires (omit for no expiration)

Successful Response

connectionId string

The SCIM connection ID

scimApiKey string

The new API key to provide to the IdP

Error Types

ScimConnectionNotFound

The provided SCIM connection ID could not be found

UnexpectedError

An unexpected error occurred during the operation

const auth = createClient({ url, integrationKey });

const result = await auth.scim.management.resetScimApiKey({
  scimConnectionId: "s8vmjNLuieN1feLOya0mf3",
  scimApiKeyExpiration: 1760232804
});

if (result.ok) {
  console.log("SCIM API key reset successfully");
  console.log(`New API Key: ${result.data.scimApiKey}`);
} else {
  console.log(`Error: ${result.error}`);
  // Check result.error.type to handle specific errors
}

client = create_client(url=url, integration_key=integration_key)

result = await client.scim.management.reset_scim_api_key(
    scim_connection_id="s8vmjNLuieN1feLOya0mf3",
    scim_api_key_expiration=1760232804
)

if is_ok(result):
    data = result.data
    print("SCIM API key reset successfully")
    print(f"New API Key: {data.scim_api_key}")
else:
    error = result.error
    print(f"Error: {error}")
    # Check error.type to handle specific errors

client, err := byo.NewClient(url, integrationKey)
if err != nil {
    log.Fatal(err)
}

result, err := client.Scim.Management.ResetScimAPIKey(ctx, &byo.ResetScimApiKeyCommandScimConnectionID{
    ScimConnectionID:     "s8vmjNLuieN1feLOya0mf3",
    ScimAPIKeyExpiration: byo.Int(1760232804),
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(result.ScimAPIKey)

PropelAuthClient client = PropelAuthClient.create(url, integrationKey);

ResetScimApiKeyCommand command = ResetScimApiKeyCommand.scimConnectionId.builder()
    .scimConnectionId("s8vmjNLuieN1feLOya0mf3")
    .scimApiKeyExpiration(1760232804)
    .build();

try {
    ResetScimApiKeyResponse response = client.scim.management.resetScimApiKey(command);
    System.out.println("SCIM API key reset successfully");
    System.out.println("New API Key: " + response.getScimApiKey());
} catch (ResetScimApiKeyException.ScimConnectionNotFound e) {
    System.out.println("SCIM connection not found");
} catch (ResetScimApiKeyException e) {
    System.out.println("Error: " + e.getMessage());
}

var client = new PropelAuthClient(new PropelAuthOptions { Url = url, IntegrationKey = integrationKey });

try
{
    var response = await client.Scim.Management.ResetScimApiKeyByScimConnectionIdAsync(
        scimConnectionId: "s8vmjNLuieN1feLOya0mf3",
        scimApiKeyExpiration: 1760232804
    );
    Console.WriteLine("SCIM API key reset successfully");
    Console.WriteLine($"New API Key: {response.ScimApiKey}");
}
catch (ResetScimApiKeyException.ScimConnectionNotFound)
{
    Console.WriteLine("SCIM connection not found");
}
catch (ResetScimApiKeyException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Response

{
  ok: true,
  data: {
    connectionId: "s8vmjNLuieN1feLOya0mf3",
    scimApiKey: "scim_s8vmjNLuieN1feLOya0mf3_YnQ4K7mPpRzL9hW3xD6gA8"
  }
}

# When successful
data = result.data
print(data.connection_id)  # "s8vmjNLuieN1feLOya0mf3"
print(data.scim_api_key)   # "scim_s8vmjNLuieN1feLOya0mf3_YnQ4K7mPpRzL9hW3xD6gA8"

byo.ResetScimApiKeyResponse{
    ConnectionID: "s8vmjNLuieN1feLOya0mf3",
    ScimAPIKey:   "scim_s8vmjNLuieN1feLOya0mf3_YnQ4K7mPpRzL9hW3xD6gA8",
}

ResetScimApiKeyResponse(
    connectionId="s8vmjNLuieN1feLOya0mf3",
    scimApiKey="scim_s8vmjNLuieN1feLOya0mf3_YnQ4K7mPpRzL9hW3xD6gA8"
)

ResetScimApiKeyResponse
{
    ConnectionId = "s8vmjNLuieN1feLOya0mf3",
    ScimApiKey = "scim_s8vmjNLuieN1feLOya0mf3_YnQ4K7mPpRzL9hW3xD6gA8"
}

Get SCIM Connection Users

Fetches user accounts that belong to the provided SCIM connection.

Arguments

scimConnectionId string

The ID of the SCIM connection

customerId string

The customer ID (alternative to scimConnectionId)

filter ScimUsersPageEqualityFilter

Filter users by userName, externalId, primaryEmail, or userId

pageNumber number

The page number to return (default: 0)

pageSize number

The number of users per page (default: 20)

Successful Response

connectionId string

The SCIM connection ID

users array

Array of complete SCIM user information

pageNumber number

The current page number

pageSize number

The number of users per page

totalResults number

Total number of users matching the filter

Error Types

ScimConnectionNotFound

The provided SCIM connection ID could not be found

InvalidQueryField

The filter field or value is invalid

UnexpectedError

An unexpected error occurred during the operation

const auth = createClient({ url, integrationKey });

const result = await auth.scim.management.getScimUsers({
  scimConnectionId: "s8vmjNLuieN1feLOya0mf3",
  filter: {
    primaryEmail: "example@propelauth.com"
  },
  pageNumber: 0,
  pageSize: 100
});

if (result.ok) {
  console.log("SCIM users fetched successfully");
  console.log(`Found ${result.data.totalResults} users`);
  result.data.users.forEach(user => {
    console.log(`User: ${user.primaryEmail}`);
  });
} else {
  console.log(`Error: ${result.error}`);
  // Check result.error.type to handle specific errors
}

client = create_client(url=url, integration_key=integration_key)

result = await client.scim.management.get_scim_users(
    scim_connection_id="s8vmjNLuieN1feLOya0mf3",
    filter=ScimUsersPageEqualityFilterPrimaryEmail("example@propelauth.com"),
    page_number=0,
    page_size=100
)

if is_ok(result):
    print("SCIM users fetched successfully")
    print(f"Found {result.data.total_results} users")
    for user in result.data.users:
        print(f"User: {user.primary_email}")
else:
    print(f"Error: {result.error}")
    # Check result.error.type to handle specific errors

client, err := byo.NewClient(url, integrationKey)
if err != nil {
    log.Fatal(err)
}

var filter byo.ScimUsersPageEqualityFilter = &byo.ScimUsersPageEqualityFilterPrimaryEmail{
    PrimaryEmail: "example@propelauth.com",
}

result, err := client.Scim.Management.GetScimUsers(ctx, &byo.GetScimUsersCommandScimConnectionID{
    ScimConnectionID: "s8vmjNLuieN1feLOya0mf3",
    Filter:           &filter,
    PageNumber:       byo.Int(0),
    PageSize:         byo.Int(100),
})
if err != nil {
    log.Fatal(err)
}

fmt.Println(result.TotalResults)

PropelAuthClient client = PropelAuthClient.create(url, integrationKey);

GetScimUsersCommand command = GetScimUsersCommand.scimConnectionId.builder()
    .scimConnectionId("s8vmjNLuieN1feLOya0mf3")
    .filter(new ScimUsersPageEqualityFilter.primaryEmail("example@propelauth.com"))
    .pageNumber(0)
    .pageSize(100)
    .build();

try {
    GetScimUsersResponse response = client.scim.management.getScimUsers(command);
    System.out.println("SCIM users fetched successfully");
    System.out.println("Found " + response.getTotalResults() + " users");
    response.getUsers().forEach(user -> {
        System.out.println("User: " + user.getPrimaryEmail());
    });
} catch (GetScimUsersException.ScimConnectionNotFound e) {
    System.out.println("SCIM connection not found");
} catch (GetScimUsersException.InvalidQueryField e) {
    System.out.println("Invalid query field: " + e.getDetails());
} catch (GetScimUsersException e) {
    System.out.println("Error: " + e.getMessage());
}

var client = new PropelAuthClient(new PropelAuthOptions { Url = url, IntegrationKey = integrationKey });

var filter = ScimUsersPageEqualityFilter.ByPrimaryEmail("example@propelauth.com");

try
{
    var response = await client.Scim.Management.GetScimUsersByScimConnectionIdAsync(
        scimConnectionId: "s8vmjNLuieN1feLOya0mf3",
        filter: filter,
        pageNumber: 0,
        pageSize: 100
    );

    Console.WriteLine("SCIM users fetched successfully");
    Console.WriteLine($"Found {response.TotalResults} users");
    foreach (var user in response.Users)
    {
        Console.WriteLine($"User: {user.PrimaryEmail}");
    }
}
catch (GetScimUsersException.ScimConnectionNotFound)
{
    Console.WriteLine("SCIM connection not found");
}
catch (GetScimUsersException.InvalidQueryField ex)
{
    Console.WriteLine($"Invalid query field: {ex.Details.Message}");
}
catch (GetScimUsersException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Response

{
  ok: true,
  data: {
    connectionId: "Yhc4Nan2ZiIPp7kyoyhT9c",
    users: [
      {
        connectionId: "Yhc4Nan2ZiIPp7kyoyhT9c",
        primaryEmail: "example@propelauth.com",
        parsedUserData: {
          // Your parsed user data, based on your property configuration
          firstName: "Example",
          lastName: "User",
          department: "Engineering",
          employeeId: "00utc0x6na8afflr0E697"
        },
        active: true,
        userId: "057806f5-6e19-45ef-ba31-238471a16fc5",
        scimUser: {
          // This is the full raw SCIM user data
          emails: [
            {
              primary: true,
              type: "work",
              value: "example@propelauth.com"
            }
          ],
          // ...
        }
      }
    ],
    pageNumber: 0,
    pageSize: 100,
    totalResults: 1
  }
}

GetScimUsersResponse(
    connection_id="Yhc4Nan2ZiIPp7kyoyhT9c",
    users=[
        CompleteScimUserResponse(
            connection_id="Yhc4Nan2ZiIPp7kyoyhT9c",
            primary_email="example@propelauth.com",
            parsed_user_data={
                # Your parsed user data, based on your property configuration
                "firstName": "Example",
                "lastName": "User",
                "department": "Engineering",
                "employeeId": "00utc0x6na8afflr0E697"
            },
            active=True,
            user_id="057806f5-6e19-45ef-ba31-238471a16fc5",
            scim_user={
                # This is the full raw SCIM user data
                "emails": [
                    {
                        "primary": True,
                        "type": "work",
                        "value": "example@propelauth.com"
                    }
                ],
                # ...
            }
        )
    ],
    page_number=0,
    page_size=100,
    total_results=1
)

byo.GetScimUsersResponse{
    ConnectionID: "Yhc4Nan2ZiIPp7kyoyhT9c",
    Users: []byo.CompleteScimUserResponse{
        {
            ConnectionID:   "Yhc4Nan2ZiIPp7kyoyhT9c",
            PrimaryEmail:   byo.String("example@propelauth.com"),
            ParsedUserData: json.RawMessage(`{"firstName": "Example", "lastName": "User", "department": "Engineering"}`),
            Active:         true,
            UserID:         byo.String("057806f5-6e19-45ef-ba31-238471a16fc5"),
            ScimUser:       json.RawMessage("{}"), // The full raw SCIM user data
        },
    },
    PageNumber:   0,
    PageSize:     100,
    TotalResults: 1,
}

GetScimUsersResponse(
    connectionId="Yhc4Nan2ZiIPp7kyoyhT9c",
    users=[
        CompleteScimUserResponse(
            connectionId="Yhc4Nan2ZiIPp7kyoyhT9c",
            primaryEmail="example@propelauth.com",
            parsedUserData={
                firstName="Example",
                lastName="User",
                department="Engineering",
                employeeId="00utc0x6na8afflr0E697"
            },
            active=true,
            userId="057806f5-6e19-45ef-ba31-238471a16fc5",
            scimUser={
                emails=[
                    {
                        primary=true,
                        type="work",
                        value="example@propelauth.com"
                    }
                ],
                ...
            }
        )
    ],
    pageNumber=0,
    pageSize=100,
    totalResults=1
)

GetScimUsersResponse
{
    ConnectionId = "Yhc4Nan2ZiIPp7kyoyhT9c",
    Users = [
        CompleteScimUserResponse
        {
            ConnectionId = "Yhc4Nan2ZiIPp7kyoyhT9c",
            PrimaryEmail = "example@propelauth.com",
            ParsedUserData = {
                // Your parsed user data, based on your property configuration
                "firstName": "Example",
                "lastName": "User",
                "department": "Engineering",
                "employeeId": "00utc0x6na8afflr0E697"
            },
            Active = true,
            UserId = "057806f5-6e19-45ef-ba31-238471a16fc5",
            ScimUser = {
                // This is the full raw SCIM user data
                "emails": [
                    {
                        "primary": true,
                        "type": "work",
                        "value": "example@propelauth.com"
                    }
                ],
                // ...
            }
        }
    ],
    PageNumber = 0,
    PageSize = 100,
    TotalResults = 1
}

Delete SCIM Connection

Deletes a SCIM connection permanently.

Arguments

scimConnectionId string

The ID of the SCIM connection

customerId string

The customer ID (alternative to scimConnectionId)

Successful Response

Returns an empty response on success

Error Types

ScimConnectionNotFound

The provided SCIM connection ID could not be found

UnexpectedError

An unexpected error occurred during the operation

const auth = createClient({ url, integrationKey });

const result = await auth.scim.management.deleteScimConnection({
  scimConnectionId: "s8vmjNLuieN1feLOya0mf3"
});

if (result.ok) {
  console.log("SCIM connection deleted successfully");
} else {
  console.log(`Error: ${result.error}`);
  // Check result.error.type to handle specific errors
}

client = create_client(url=url, integration_key=integration_key)

result = await client.scim.management.delete_scim_connection(
    scim_connection_id="s8vmjNLuieN1feLOya0mf3"
)

if is_ok(result):
    print("SCIM connection deleted successfully")
else:
    print(f"Error: {result.error.type}")
    # Check result.error.type to handle specific errors

client, err := byo.NewClient(url, integrationKey)
if err != nil {
    log.Fatal(err)
}

_, err = client.Scim.Management.DeleteScimConnection(ctx, &byo.DeleteScimConnectionCommandScimConnectionID{
    ScimConnectionID: "s8vmjNLuieN1feLOya0mf3",
})
if err != nil {
    log.Fatal(err)
}

PropelAuthClient client = PropelAuthClient.create(url, integrationKey);

DeleteScimConnectionCommand command = DeleteScimConnectionCommand.scimConnectionId.builder()
    .scimConnectionId("s8vmjNLuieN1feLOya0mf3")
    .build();

try {
    DeleteScimConnectionResponse response = client.scim.management.deleteScimConnection(command);
    System.out.println("SCIM connection deleted successfully");
} catch (DeleteScimConnectionException.ScimConnectionNotFound e) {
    System.out.println("SCIM connection not found");
} catch (DeleteScimConnectionException e) {
    System.out.println("Error: " + e.getMessage());
}

var client = new PropelAuthClient(new PropelAuthOptions { Url = url, IntegrationKey = integrationKey });

try
{
    await client.Scim.Management.DeleteScimConnectionByScimConnectionIdAsync("s8vmjNLuieN1feLOya0mf3");
    Console.WriteLine("SCIM connection deleted successfully");
}
catch (DeleteScimConnectionException.ScimConnectionNotFound)
{
    Console.WriteLine("SCIM connection not found");
}
catch (DeleteScimConnectionException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Response

{
  ok: true,
  data: {}
}

Result(
    data=DeleteScimConnectionResponse()
)

byo.DeleteScimConnectionResponse{}

DeleteScimConnectionResponse()

DeleteScimConnectionResponse()

SCIM Config

The 'scim_config.jsonc' file allows you to set a default SCIM mapping configuration. This can be used to map properties (name, address, etc.) from your user's SCIM providers to your application.

Arguments

outputField string required

The key for the property where the mapped data should be placed. Will be included whenever the SCIM user is returned, such as the Get SCIM User Command.

inputPath string required

The path in the raw SCIM data where this property is expected to be found.

propertyType JSON required

The type of the property. If set to the List type, you must include an ItemType property with it's own dataType. If set to the Enum type, you must include an options property that includes each available option for the enum. The dataType property must equal one of the following:

String
Integer
Float
Boolean
Date
DateTime
Enum
List

fallbackInputPaths string[]

Fallback paths in the raw SCIM data. Will be used if inputPath is not found.

displayName string

A human readable name for the property.

description string

A description of the property.

warnIfMissing boolean

Defaults to false. If true, a warning will be surfaced in the Dashboard if this property could not be found.

defaultValue string

A value to be returned if the property could not be found in the incoming SCIM data.

{
  "userSchema": [
    {
      "outputField": "familyName",
      "inputPath": "name.familyName",
      "fallbackInputPaths": [
          "lastName",
          "last_name",
      ],
      "propertyType": {
          "dataType": "String",
      },
      "displayName": "Family Name",
      "description": "The user's family name.",
      "warnIfMissing": true,
      "defaultValue": "Unknown",
    },
    {
      "outputField": "givenName",
      "inputPath": "name.givenName",
      "displayName": "Preferred Name",
      "description": null,
      "propertyType": {
        "dataType": "String",
      },
    },
    {
      "outputField": "phoneNumbers",
      "inputPath": "phoneNumbers[type eq "work"].value",
      "displayName": "Work Phone Numbers",
      "description": "A list of all your work phone numbers.",
      "propertyType": {
        "dataType": "List",
        "itemType": {
          "dataType": "String",
        },
      },
    },
    {
      "outputField": "department",
      "inputPath": "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:department",
      "displayName": "Department",
      "description": "Your department.",
      "propertyType": {
        "dataType": "Enum",
        "options": [
          "Engineering",
          "Sales",
          "Marketing",
          "Human Resources",
          "Finance",
          "Customer Support",
          "Legal",
          "Operations",
        ],
      },
    },
    {
      "outputField": "manager",
      "inputPath": "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User:manager",
      "displayName": "My Manager",
      "description": "Your manager's name.",
      "propertyType": {
          "dataType": "String",
      },
    },
  ],
}