> This page is for Developers.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://zuora.ferndocs.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://zuora.ferndocs.com/_mcp/server.

# Retrieve the service provider configuration

GET https://rest.test.zuora.com/scim/v2/ServiceProviderConfig

Returns Zuora’s service provider configuration.

Reference: https://zuora.ferndocs.com/developers/api-reference/zuora-api/oneid/scim/get-the-service-provider-config

## Authentication

- `Authorization` header (bearer token, required) — Use `Bearer {{token}}` in the `Authorization` header for authentication.

## Servers

- `https://rest.test.zuora.com` (US Developer & Central Sandbox (incl. Test Drive), default)
- `https://rest.sandbox.na.zuora.com` (US API Sandbox Cloud 1)
- `https://rest.apisandbox.zuora.com` (US API Sandbox Cloud 2)
- `https://rest.na.zuora.com` (US Production Cloud 1)
- `https://rest.zuora.com` (US Production Cloud 2)
- `https://rest.test.eu.zuora.com` (EU Developer & Central Sandbox)
- `https://rest.sandbox.eu.zuora.com` (EU API Sandbox)
- `https://rest.eu.zuora.com` (EU Production)
- `https://rest.test.ap.zuora.com` (APAC Developer & Central Sandbox)
- `https://rest.ap.zuora.com` (APAC Production)

## Response

### 200

OK

- `schemas` (list of string, optional) — List of schema URNs that define the structure of the response.
- `patch` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaPatch, optional) — Details about support for the PATCH method.
- `bulk` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaBulk, optional) — Details about support for bulk operations.
- `filter` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaFilter, optional) — Details about support for filtering resources.
- `changePassword` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaChangePassword, optional) — Details about support for password change operations.
- `sort` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaSort, optional) — Details about support for sorting resources.
- `etag` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaEtag, optional) — Details about support for ETag headers.
- `authenticationSchemes` (list of ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaAuthenticationSchemesItems, optional) — List of authentication schemes supported by the service provider.
- `meta` (ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaMeta, optional) — Metadata about the service provider configuration.

## Errors

### 401 Unauthorized Error

Unauthorized - The request requires user authentication.

- `success` (boolean, optional) — Indicates whether the operation was successful or not.
- `reasons` (list of ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaReasonsItems, optional) — A list of reasons explaining why the request was unauthorized.

### 403 Forbidden Error

Forbidden - The server understands the request but refuses to authorize it.

- `timestamp` (datetime, optional) — The timestamp when the error occurred.
- `status` (integer, optional) — HTTP status code representing the error.
- `error` (string, optional) — A brief description of the error.
- `message` (string, optional) — A message explaining why access was forbidden.
- `path` (string, optional) — The path of the request that caused the error.

### 404 Not Found Error

Not Found - The requested resource could not be found.

- `schemas` (list of string, optional) — A list of schema URNs that describe the structure of the error response.
- `status` (string, optional) — HTTP status code representing the error.
- `detail` (string, optional) — A detailed message explaining the resource not found error.

## Types

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaPatch

Details about support for the PATCH method.

- `supported` (boolean, optional) — Indicates whether the PATCH method is supported.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaBulk

Details about support for bulk operations.

- `supported` (boolean, optional) — Indicates whether bulk operations are supported.
- `maxOperations` (integer, optional) — The maximum number of operations that can be performed in a single bulk request.
- `maxPayloadSize` (integer, optional) — The maximum size of the payload for a single bulk request, in bytes.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaFilter

Details about support for filtering resources.

- `supported` (boolean, optional) — Indicates whether filtering is supported.
- `maxResults` (integer, optional) — The maximum number of results that can be returned in a single request when using filters.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaChangePassword

Details about support for password change operations.

- `supported` (boolean, optional) — Indicates whether password change operations are supported.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaSort

Details about support for sorting resources.

- `supported` (boolean, optional) — Indicates whether sorting is supported.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaEtag

Details about support for ETag headers.

- `supported` (boolean, optional) — Indicates whether ETag headers are supported.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaAuthenticationSchemesItems

- `name` (string, optional) — The name of the authentication scheme.
- `description` (string, optional) — A description of how the authentication scheme works.
- `specUri` (string, optional) — A URI to the specification of the authentication scheme.
- `type` (string, optional) — The type of the authentication scheme (e.g., OAuth2).
- `primary` (boolean, optional) — Indicates whether this is the primary authentication scheme.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaMeta

Metadata about the service provider configuration.

- `resourceType` (string, optional) — Type of the resource returned (e.g., ServiceProviderConfig).
- `location` (string, optional) — URI of the resource.

### ScimV2ServiceProviderConfigGetResponsesContentApplicationJsonSchemaReasonsItems

- `message` (string, optional) — A message describing the reason for the unauthorized error.
- `code` (string, optional) — An error code associated with the unauthorized error.

## Examples

**Response**

```json
{
  "schemas": [
    "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"
  ],
  "patch": {
    "supported": true
  },
  "bulk": {
    "supported": true,
    "maxOperations": 1000,
    "maxPayloadSize": 10000
  },
  "filter": {
    "supported": true,
    "maxResults": 100
  },
  "changePassword": {
    "supported": false
  },
  "sort": {
    "supported": false
  },
  "etag": {
    "supported": false
  },
  "authenticationSchemes": [
    {
      "name": "Client Credentials",
      "description": "The client credentials (or other forms of client authentication) can be used as an authorization grant when the authorization scope is limited to the protected resources under the control of the client, or to protected resources previously arranged with the authorization server. Client credentials are used as an authorization grant typically when the client is acting on its own behalf (the client is also the resource owner) or is requesting access to protected resources based on an authorization previously arranged with the authorization server.\n",
      "specUri": "https://www.rfc-editor.org/rfc/rfc6749#section-4.4",
      "type": "oauth2",
      "primary": true
    },
    {
      "name": "Authorization Grant",
      "description": "An authorization grant is a credential representing the resource owner's authorization (to access its protected resources) used by the client to obtain an access token. This specification defines four grant types -- authorization code, implicit, resource owner password credentials, and client credentials -- as well as an extensibility mechanism for defining additional types.\n",
      "specUri": "https://www.rfc-editor.org/rfc/rfc6749#section-4.1",
      "type": "oauth2",
      "primary": false
    }
  ],
  "meta": {
    "resourceType": "ServiceProviderConfig",
    "location": "http://localhost:9900/scim/v2/ServiceProviderConfig"
  }
}
```

**SDK Code**

```python
import requests

url = "https://rest.test.zuora.com/scim/v2/ServiceProviderConfig"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://rest.test.zuora.com/scim/v2/ServiceProviderConfig';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://rest.test.zuora.com/scim/v2/ServiceProviderConfig"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://rest.test.zuora.com/scim/v2/ServiceProviderConfig")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://rest.test.zuora.com/scim/v2/ServiceProviderConfig")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://rest.test.zuora.com/scim/v2/ServiceProviderConfig', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://rest.test.zuora.com/scim/v2/ServiceProviderConfig");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://rest.test.zuora.com/scim/v2/ServiceProviderConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```