---
title: Update Identity Provider
description: To update a property value associated with a selected identity provider resource, use the PUT {{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}} operation to modify the specified attribute values. For example, you can change the description attribute value of the identity provider.
component: pingone-api
page_id: pingone-api:platform:identity-provider-management/identity-providers/update-identity-provider
canonical_url: https://developer.pingidentity.com/pingone-api/platform/identity-provider-management/identity-providers/update-identity-provider.html
section_ids:
  prerequisites: Prerequisites
  headers: Headers
  body: Body
  example-request: Example Request
  example-response: Example Response
---

# Update Identity Provider

##

```none
PUT {{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}
```

To update a property value associated with a selected identity provider resource, use the `PUT {{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}` operation to modify the specified attribute values. For example, you can change the `description` attribute value of the identity provider.

If the client secret has been updated, you must also update the client secret in both the PingOne configuration for the OIDC external identity provider, and the external OpenID provider.

|   |                                                                                                                                                                                                                      |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|   | For trademarked identity providers such as Facebook, Google, and LinkedIn, updates to the `loginButtonIcon.id` and `loginButtonIcon.href` properties are ignored to preserve the identity provider's branding rules. |

### Prerequisites

* Refer to [Identity Provider Management](../../identity-provider-management.html) for important overview information.

### Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

### Body

raw ( application/json )

```json
{
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "type": "SAML",
    "enabled": false,
    "spEntityId": "sp-{$timestamp}",
    "idpEntityId": "idp-{$timestamp}",
    "ssoBinding": "HTTP_POST",
    "ssoEndpoint": "https://idp.com/sso",
    "authnRequestSigned": "false",
    "idpVerification": {
        "certificates": [
            {
                "id": "{{certID}}"
            }
        ]
    },
    "spSigning": {
        "key": {
            "id": "{{spSigningID}}"
        }
    }
}
```

##

### Example Request

* cURL

* C#

* Go

* HTTP

* Java

* jQuery

* NodeJS

* Python

* PHP

* Ruby

* Swift

```shell
curl --location --globoff --request PUT '{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "type": "SAML",
    "enabled": false,
    "spEntityId": "sp-{$timestamp}",
    "idpEntityId": "idp-{$timestamp}",
    "ssoBinding": "HTTP_POST",
    "ssoEndpoint": "https://idp.com/sso",
    "authnRequestSigned": "false",
    "idpVerification": {
        "certificates": [
            {
                "id": "{{certID}}"
            }
        ]
    },
    "spSigning": {
        "key": {
            "id": "{{spSigningID}}"
        }
    }
}'
```

```csharp
var options = new RestClientOptions("{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}")
{
  MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("", Method.Put);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer {{accessToken}}");
var body = @"{" + "\n" +
@"    ""name"": ""SAMLIdP""," + "\n" +
@"    ""description"": ""This is s SAML IdP test""," + "\n" +
@"    ""type"": ""SAML""," + "\n" +
@"    ""enabled"": false," + "\n" +
@"    ""spEntityId"": ""sp-{$timestamp}""," + "\n" +
@"    ""idpEntityId"": ""idp-{$timestamp}""," + "\n" +
@"    ""ssoBinding"": ""HTTP_POST""," + "\n" +
@"    ""ssoEndpoint"": ""https://idp.com/sso""," + "\n" +
@"    ""authnRequestSigned"": ""false""," + "\n" +
@"    ""idpVerification"": {" + "\n" +
@"        ""certificates"": [" + "\n" +
@"            {" + "\n" +
@"                ""id"": ""{{certID}}""" + "\n" +
@"            }" + "\n" +
@"        ]" + "\n" +
@"    }," + "\n" +
@"    ""spSigning"": {" + "\n" +
@"        ""key"": {" + "\n" +
@"            ""id"": ""{{spSigningID}}""" + "\n" +
@"        }" + "\n" +
@"    }" + "\n" +
@"}";
request.AddStringBody(body, DataFormat.Json);
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);
```

```golang
package main

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

func main() {

  url := "{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}"
  method := "PUT"

  payload := strings.NewReader(`{
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "type": "SAML",
    "enabled": false,
    "spEntityId": "sp-{$timestamp}",
    "idpEntityId": "idp-{$timestamp}",
    "ssoBinding": "HTTP_POST",
    "ssoEndpoint": "https://idp.com/sso",
    "authnRequestSigned": "false",
    "idpVerification": {
        "certificates": [
            {
                "id": "{{certID}}"
            }
        ]
    },
    "spSigning": {
        "key": {
            "id": "{{spSigningID}}"
        }
    }
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("Authorization", "Bearer {{accessToken}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

```http
PUT /v1/environments/{{envID}}/identityProviders/{{providerID}} HTTP/1.1
Host: {{apiPath}}
Content-Type: application/json
Authorization: Bearer {{accessToken}}

{
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "type": "SAML",
    "enabled": false,
    "spEntityId": "sp-{$timestamp}",
    "idpEntityId": "idp-{$timestamp}",
    "ssoBinding": "HTTP_POST",
    "ssoEndpoint": "https://idp.com/sso",
    "authnRequestSigned": "false",
    "idpVerification": {
        "certificates": [
            {
                "id": "{{certID}}"
            }
        ]
    },
    "spSigning": {
        "key": {
            "id": "{{spSigningID}}"
        }
    }
}
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n    \"name\": \"SAMLIdP\",\n    \"description\": \"This is s SAML IdP test\",\n    \"type\": \"SAML\",\n    \"enabled\": false,\n    \"spEntityId\": \"sp-{$timestamp}\",\n    \"idpEntityId\": \"idp-{$timestamp}\",\n    \"ssoBinding\": \"HTTP_POST\",\n    \"ssoEndpoint\": \"https://idp.com/sso\",\n    \"authnRequestSigned\": \"false\",\n    \"idpVerification\": {\n        \"certificates\": [\n            {\n                \"id\": \"{{certID}}\"\n            }\n        ]\n    },\n    \"spSigning\": {\n        \"key\": {\n            \"id\": \"{{spSigningID}}\"\n        }\n    }\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}")
  .method("PUT", body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer {{accessToken}}")
  .build();
Response response = client.newCall(request).execute();
```

```javascript
var settings = {
  "url": "{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}",
  "method": "PUT",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "type": "SAML",
    "enabled": false,
    "spEntityId": "sp-{$timestamp}",
    "idpEntityId": "idp-{$timestamp}",
    "ssoBinding": "HTTP_POST",
    "ssoEndpoint": "https://idp.com/sso",
    "authnRequestSigned": "false",
    "idpVerification": {
      "certificates": [
        {
          "id": "{{certID}}"
        }
      ]
    },
    "spSigning": {
      "key": {
        "id": "{{spSigningID}}"
      }
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
```

```javascript
var request = require('request');
var options = {
  'method': 'PUT',
  'url': '{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "type": "SAML",
    "enabled": false,
    "spEntityId": "sp-{$timestamp}",
    "idpEntityId": "idp-{$timestamp}",
    "ssoBinding": "HTTP_POST",
    "ssoEndpoint": "https://idp.com/sso",
    "authnRequestSigned": "false",
    "idpVerification": {
      "certificates": [
        {
          "id": "{{certID}}"
        }
      ]
    },
    "spSigning": {
      "key": {
        "id": "{{spSigningID}}"
      }
    }
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

```python
import requests
import json

url = "{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}"

payload = json.dumps({
  "name": "SAMLIdP",
  "description": "This is s SAML IdP test",
  "type": "SAML",
  "enabled": False,
  "spEntityId": "sp-{$timestamp}",
  "idpEntityId": "idp-{$timestamp}",
  "ssoBinding": "HTTP_POST",
  "ssoEndpoint": "https://idp.com/sso",
  "authnRequestSigned": "false",
  "idpVerification": {
    "certificates": [
      {
        "id": "{{certID}}"
      }
    ]
  },
  "spSigning": {
    "key": {
      "id": "{{spSigningID}}"
    }
  }
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {{accessToken}}'
}

response = requests.request("PUT", url, headers=headers, data=payload)

print(response.text)
```

```php
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}');
$request->setMethod(HTTP_Request2::METHOD_PUT);
$request->setConfig(array(
  'follow_redirects' => TRUE
));
$request->setHeader(array(
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {{accessToken}}'
));
$request->setBody('{\n    "name": "SAMLIdP",\n    "description": "This is s SAML IdP test",\n    "type": "SAML",\n    "enabled": false,\n    "spEntityId": "sp-{$timestamp}",\n    "idpEntityId": "idp-{$timestamp}",\n    "ssoBinding": "HTTP_POST",\n    "ssoEndpoint": "https://idp.com/sso",\n    "authnRequestSigned": "false",\n    "idpVerification": {\n        "certificates": [\n            {\n                "id": "{{certID}}"\n            }\n        ]\n    },\n    "spSigning": {\n        "key": {\n            "id": "{{spSigningID}}"\n        }\n    }\n}');
try {
  $response = $request->send();
  if ($response->getStatus() == 200) {
    echo $response->getBody();
  }
  else {
    echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
    $response->getReasonPhrase();
  }
}
catch(HTTP_Request2_Exception $e) {
  echo 'Error: ' . $e->getMessage();
}
```

```ruby
require "uri"
require "json"
require "net/http"

url = URI("{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Put.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer {{accessToken}}"
request.body = JSON.dump({
  "name": "SAMLIdP",
  "description": "This is s SAML IdP test",
  "type": "SAML",
  "enabled": false,
  "spEntityId": "sp-{\$timestamp}",
  "idpEntityId": "idp-{\$timestamp}",
  "ssoBinding": "HTTP_POST",
  "ssoEndpoint": "https://idp.com/sso",
  "authnRequestSigned": "false",
  "idpVerification": {
    "certificates": [
      {
        "id": "{{certID}}"
      }
    ]
  },
  "spSigning": {
    "key": {
      "id": "{{spSigningID}}"
    }
  }
})

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

```swift
let parameters = "{\n    \"name\": \"SAMLIdP\",\n    \"description\": \"This is s SAML IdP test\",\n    \"type\": \"SAML\",\n    \"enabled\": false,\n    \"spEntityId\": \"sp-{$timestamp}\",\n    \"idpEntityId\": \"idp-{$timestamp}\",\n    \"ssoBinding\": \"HTTP_POST\",\n    \"ssoEndpoint\": \"https://idp.com/sso\",\n    \"authnRequestSigned\": \"false\",\n    \"idpVerification\": {\n        \"certificates\": [\n            {\n                \"id\": \"{{certID}}\"\n            }\n        ]\n    },\n    \"spSigning\": {\n        \"key\": {\n            \"id\": \"{{spSigningID}}\"\n        }\n    }\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "{{apiPath}}/v1/environments/{{envID}}/identityProviders/{{providerID}}")!,timeoutInterval: Double.infinity)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("Bearer {{accessToken}}", forHTTPHeaderField: "Authorization")

request.httpMethod = "PUT"
request.httpBody = postData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data else {
    print(String(describing: error))
    return
  }
  print(String(data: data, encoding: .utf8)!)
}

task.resume()
```

### Example Response

200 OK

```json
{
    "_links": {
        "self": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/identityProviders/a9e4e181-f520-4e6e-af30-d3559781ad1b"
        },
        "environment": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
        },
        "attributes": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/identityProviders/a9e4e181-f520-4e6e-af30-d3559781ad1b/attributes"
        }
    },
    "id": "a9e4e181-f520-4e6e-af30-d3559781ad1b",
    "type": "SAML",
    "name": "SAMLIdP",
    "description": "This is s SAML IdP test",
    "enabled": false,
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    },
    "createdAt": "2019-06-17T17:20:12.294Z",
    "updatedAt": "2021-06-02T09:24:26.468Z",
    "_embedded": {
        "attributes": [
            {
                "name": "username",
                "value": "${samlAssertion.subject}",
                "update": "EMPTY_ONLY",
                "id": "51a036c6-41ed-44f7-bd1d-eacaa2a1feab",
                "mappingType": "CORE",
                "environment": {
                    "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
                },
                "identityProvider": {
                    "id": "a9e4e181-f520-4e6e-af30-d3559781ad1b"
                },
                "createdAt": "2019-06-17T17:20:12.294Z",
                "updatedAt": "2019-06-17T17:20:12.294Z"
            }
        ]
    },
    "authnRequestSigned": false,
    "ssoEndpoint": "https://idp.com/sso",
    "ssoBinding": "HTTP_POST",
    "idpVerification": {
        "certificates": [
            {
                "id": "123f67f8-c56c-4903-9c9b-c4b162e22789"
            }
        ]
    },
    "spEntityId": "sp-1560792011",
    "spSigning": {
        "key": {
            "id": "a65318d7-eaa2-4070-bb73-ffe21a6fca06"
        }
    },
    "idpEntityId": "idp-1560792011"
}
```
