---
title: Create Decision Endpoint
description: There are two create options. You can configure a policy decision endpoint to reference a specific policy version. Or, you can configure a policy decision endpoint that is always up-to-date.
component: pingone-api
page_id: pingone-api:authorize:authorization-decisions/decision-endpoints/create-decision-endpoint
canonical_url: https://developer.pingidentity.com/pingone-api/authorize/authorization-decisions/decision-endpoints/create-decision-endpoint.html
section_ids:
  prerequisites: Prerequisites
  headers: Headers
  body: Body
  example-request: Example Request
  example-response: Example Response
---

# Create Decision Endpoint

##

```none
POST {{apiPath}}/v1/environments/{{envID}}/decisionEndpoints
```

There are two create options. You can configure a policy decision endpoint to reference a specific policy version. Or, you can configure a policy decision endpoint that is always up-to-date.

In cases where a specific policy version is defined in the request, the policy decision service fetches the policy configuration at that version from the policy editor service and stores it locally. When no policy version is defined (always up-to-date), the decision endpoint is recorded in the local database with no policy configuration. Access to the policy editor service is not required in this case.

The following sample shows the `POST {{apiPath}}/v1/environments/{{envID}}/decisionEndpoints` operation to create a new policy decision endpoint resource associated with the environment specified in the request URL. The request body specifies the `name`, `description`, `authorizationVersion` (the policy version), and `recordRecentRequests` attributes.

|   |                                                                                                                                                                                    |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|   | When a policy decision endpoint does not specify a policy version, the policy decision service fetches the current policy configuration at runtime from the policy editor service. |

### Prerequisites

* Refer to [Authorization Decisions](../decision-endpoints.html) for important overview information.

> **Collapse: Request Model**
>
> For property descriptions, refer to [Policy decision service data model](../decision-endpoints.html#policy-decision-service-data-model).
>
> | Property                  | Type?   | Required? |
> | ------------------------- | ------- | --------- |
> | `alternateId`             | UUID    | Optional  |
> | `authorizationVersion.id` | UUID    | Optional  |
> | `description`             | String  | Required  |
> | `id`                      | UUID    | Required  |
> | `name`                    | String  | Required  |
> | `owned`                   | Boolean | Optional  |
> | `policyId`                | UUID    | Optional  |
> | `recordRecentRequests`    | Boolean | Required  |

### Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

### Body

raw ( application/json )

```json
{
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
        "id": "{{authorizationVersionID}}"
    },
    "recordRecentRequests": true
}
```

##

### Example Request

* cURL

* C#

* Go

* HTTP

* Java

* jQuery

* NodeJS

* Python

* PHP

* Ruby

* Swift

```shell
curl --location --globoff '{{apiPath}}/v1/environments/{{envID}}/decisionEndpoints' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
        "id": "{{authorizationVersionID}}"
    },
    "recordRecentRequests": true
}'
```

```csharp
var options = new RestClientOptions("{{apiPath}}/v1/environments/{{envID}}/decisionEndpoints")
{
  MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("", Method.Post);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer {{accessToken}}");
var body = @"{" + "\n" +
@"    ""name"": ""Test Endpoint""," + "\n" +
@"    ""description"": ""Endpoint for use in tests""," + "\n" +
@"    ""authorizationVersion"": {" + "\n" +
@"        ""id"": ""{{authorizationVersionID}}""" + "\n" +
@"    }," + "\n" +
@"    ""recordRecentRequests"": 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}}/decisionEndpoints"
  method := "POST"

  payload := strings.NewReader(`{
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
        "id": "{{authorizationVersionID}}"
    },
    "recordRecentRequests": 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
POST /v1/environments/{{envID}}/decisionEndpoints HTTP/1.1
Host: {{apiPath}}
Content-Type: application/json
Authorization: Bearer {{accessToken}}

{
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
        "id": "{{authorizationVersionID}}"
    },
    "recordRecentRequests": true
}
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n    \"name\": \"Test Endpoint\",\n    \"description\": \"Endpoint for use in tests\",\n    \"authorizationVersion\": {\n        \"id\": \"{{authorizationVersionID}}\"\n    },\n    \"recordRecentRequests\": true\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/v1/environments/{{envID}}/decisionEndpoints")
  .method("POST", 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}}/decisionEndpoints",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
      "id": "{{authorizationVersionID}}"
    },
    "recordRecentRequests": true
  }),
};

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

```javascript
var request = require('request');
var options = {
  'method': 'POST',
  'url': '{{apiPath}}/v1/environments/{{envID}}/decisionEndpoints',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
      "id": "{{authorizationVersionID}}"
    },
    "recordRecentRequests": 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}}/decisionEndpoints"

payload = json.dumps({
  "name": "Test Endpoint",
  "description": "Endpoint for use in tests",
  "authorizationVersion": {
    "id": "{{authorizationVersionID}}"
  },
  "recordRecentRequests": True
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {{accessToken}}'
}

response = requests.request("POST", 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}}/decisionEndpoints');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
  'follow_redirects' => TRUE
));
$request->setHeader(array(
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {{accessToken}}'
));
$request->setBody('{\n    "name": "Test Endpoint",\n    "description": "Endpoint for use in tests",\n    "authorizationVersion": {\n        "id": "{{authorizationVersionID}}"\n    },\n    "recordRecentRequests": 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}}/decisionEndpoints")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer {{accessToken}}"
request.body = JSON.dump({
  "name": "Test Endpoint",
  "description": "Endpoint for use in tests",
  "authorizationVersion": {
    "id": "{{authorizationVersionID}}"
  },
  "recordRecentRequests": true
})

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

```swift
let parameters = "{\n    \"name\": \"Test Endpoint\",\n    \"description\": \"Endpoint for use in tests\",\n    \"authorizationVersion\": {\n        \"id\": \"{{authorizationVersionID}}\"\n    },\n    \"recordRecentRequests\": true\n}"
let postData = parameters.data(using: .utf8)

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

request.httpMethod = "POST"
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

201 Created

```json
{
    "_links": {
        "self": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/decisionEndpoints/bcb106be-96fa-4479-b3ee-dbd7666e4da2"
        },
        "authorizationVersion": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/authorizationVersions/d7437c70-3082-11ee-80bd-adfbbca2bf5b"
        },
        "environment": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
        }
    },
    "id": "bcb106be-96fa-4479-b3ee-dbd7666e4da2",
    "name": "Test Endpoint",
    "description": "Endpoint for use in tests",
    "authorizationVersion": {
        "id": "d7437c70-3082-11ee-80bd-adfbbca2bf5b"
    },
    "recordRecentRequests": true,
    "owned": false,
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    }
}
```
