---
title: "Step 7: Enable user MFA"
description: The POST {{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled operation enables MFA for the specified user.
component: pingone-api
page_id: pingone-api:getting-started:create-a-test-environment/step-7-enable-user-mfa
canonical_url: https://developer.pingidentity.com/pingone-api/getting-started/create-a-test-environment/step-7-enable-user-mfa.html
section_ids:
  troubleshooting: Troubleshooting
  headers: Headers
  body: Body
  example-request: Example Request
  example-response: Example Response
---

# Step 7: Enable user MFA

##

```none
PUT {{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled
```

The `POST {{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled` operation enables MFA for the specified user.

In this request:

* `{{apiPath}}` is the geographic domain for the PingOne API endpoints for your PingOne environment. The PingOne top-level domain is `https://api.pingone.com/v1` for the U.S. Refer to [PingOne API domains](../../before-you-begin/introduction.html) for the top-level domains for other regions.

* `{{envID}}` is the ID of the environment you created in the previous step. If you're using Postman, this value is automatically set by the script in the Script tab used for the previous step.

* `{{sharedUserID}}` is the ID for the user you created in the step to create a user. If you're using Postman, this has been automatically set for you by the script in the Script tab when you created the new user.

In the request body:

* `mfaEnabled` indicates whether to enable MFA for the user. This must be set to `true` to allow the user to authenticate using MFA. The default value is `false`.

A successful response returns a `Status: 200 successful` message, and shows the user's password `status` of `OK`.

### Troubleshooting

* Verify that `{{envID}}` is the ID for the new test environment you created.

* Verify that you've assigned either the Environment Admin or Identity Admin role to your Worker app. Refer to [Assign roles to the Worker app](../create-an-admin-worker-app/step-3-assign-roles.html).

* Verify that the `{{sharedUserID}}` value is the user ID value returned by the step to create a user. For Postman users, unassigned variables are shown in red, and assigned variables in blue.

* Verify that you're using Bearer authorization for this request (and all `{{apiPath}}` requests). For Postman users, check that the Authorization tab in Postman is set to Bearer Token, and the access token variable is assigned (shown in blue, not red).

* If you get a 401 Unauthorized message, this is likely due to the access token expiring (a 1 hour expiry time). Refer to the step to get an access token, and call this request again.

* Verify that `{{apiPath}}` is correct for your geographic domain .

### Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

### Body

raw ( application/json )

```json
{
    "mfaEnabled": true
}
```

##

### Example Request

* cURL

* C#

* Go

* HTTP

* Java

* jQuery

* NodeJS

* Python

* PHP

* Ruby

* Swift

```shell
curl --location --globoff --request PUT '{{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
    "mfaEnabled": true
}'
```

```csharp
var options = new RestClientOptions("{{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled")
{
  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" +
@"    ""mfaEnabled"": true" + "\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}}/users/{{sharedUserID}}/mfaEnabled"
  method := "PUT"

  payload := strings.NewReader(`{
    "mfaEnabled": true
}`)

  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}}/users/{{sharedUserID}}/mfaEnabled HTTP/1.1
Host: {{apiPath}}
Content-Type: application/json
Authorization: Bearer {{accessToken}}

{
    "mfaEnabled": true
}
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n    \"mfaEnabled\": true\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled")
  .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}}/users/{{sharedUserID}}/mfaEnabled",
  "method": "PUT",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "mfaEnabled": true
  }),
};

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

```javascript
var request = require('request');
var options = {
  'method': 'PUT',
  'url': '{{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "mfaEnabled": true
  })

};
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}}/users/{{sharedUserID}}/mfaEnabled"

payload = json.dumps({
  "mfaEnabled": True
})
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}}/users/{{sharedUserID}}/mfaEnabled');
$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    "mfaEnabled": true\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}}/users/{{sharedUserID}}/mfaEnabled")

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({
  "mfaEnabled": true
})

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

```swift
let parameters = "{\n    \"mfaEnabled\": true\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "{{apiPath}}/v1/environments/{{envID}}/users/{{sharedUserID}}/mfaEnabled")!,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/users/b7119e13-9612-42d0-a57c-039e74a0f27c/mfaEnabled"
        },
        "user": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/users/b7119e13-9612-42d0-a57c-039e74a0f27c"
        }
    },
    "mfaEnabled": true
}
```
