---
title: Create Risk Predictor (Custom - numeric range)
description: This example uses the riskPredictors endpoint to create a custom predictor that assigns high, medium, or low risk based on the distance between the current location of the device and the location of the device when the last risk evaluation was carried out (distance is given in meters).
component: pingone-api
page_id: pingone-api:protect:risk-predictors/create_risk_predictor_custom_numeric_range
canonical_url: https://developer.pingidentity.com/pingone-api/protect/risk-predictors/create_risk_predictor_custom_numeric_range.html
section_ids:
  prerequisites: Prerequisites
  headers: Headers
  body: Body
  example-request: Example Request
  example-response: Example Response
---

# Create Risk Predictor (Custom - numeric range)

##

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

This example uses the `riskPredictors` endpoint to create a custom predictor that assigns high, medium, or low risk based on the distance between the current location of the device and the location of the device when the last risk evaluation was carried out (distance is given in meters).

The `minScore` and `maxScore` properties are used to specify the ranges that should be considered high, medium, and low risk.

Note that the `maxScore` value for each of the risk categories is used as the `minScore` for the next risk level. If the distance equals the overlap value, the higher level of risk is assigned. So in this example, a distance of 804672 meters would be considered high risk.

`type` is set to MAP to indicate that it is a custom predictor.

### Prerequisites

* Refer to [Risk Predictors](#risk-predictors) for important overview information.

> **Collapse: Request Model**
>
> Refer to [Risk Predictors](#risk-predictors) for the complete data models.
>
> | Property                            | Type   | Required? |
> | ----------------------------------- | ------ | --------- |
> | `compactName`                       | String | Required  |
> | `default`                           | Object | Optional  |
> | `default.result.level`              | String | Optional  |
> | `map.<risk level>.between.minScore` | Double | Required  |
> | `map.<risk level>.between.maxScore` | Double | Required  |
> | `map.<risk level>.contains`         | Double | Required  |
> | `name`                              | String | Required  |
> | `type`                              | String | Required  |

### Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

### Body

raw ( application/json )

```json
{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}
```

##

### Example Request

* cURL

* C#

* Go

* HTTP

* Java

* jQuery

* NodeJS

* Python

* PHP

* Ruby

* Swift

```shell
curl --location --globoff '{{apiPath}}/v1/environments/{{envID}}/riskPredictors' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}'
```

```csharp
var options = new RestClientOptions("{{apiPath}}/v1/environments/{{envID}}/riskPredictors")
{
  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"": ""Device Network Location""," + "\n" +
@"  ""compactName"": ""deviceNetworkLocation""," + "\n" +
@"  ""map"": {" + "\n" +
@"    ""high"": {" + "\n" +
@"      ""between"": {" + "\n" +
@"        ""minScore"": 804672," + "\n" +
@"        ""maxScore"": 12742000" + "\n" +
@"      }," + "\n" +
@"      ""contains"": ""${details.device.estimatedDistance}""" + "\n" +
@"    }," + "\n" +
@"    ""medium"": {" + "\n" +
@"      ""between"": {" + "\n" +
@"        ""minScore"": 321869," + "\n" +
@"        ""maxScore"": 804672" + "\n" +
@"      }," + "\n" +
@"      ""contains"": ""${details.device.estimatedDistance}""" + "\n" +
@"    }," + "\n" +
@"    ""low"": {" + "\n" +
@"      ""between"": {" + "\n" +
@"        ""minScore"": 0," + "\n" +
@"        ""maxScore"": 321869" + "\n" +
@"      }," + "\n" +
@"      ""contains"": ""${details.device.estimatedDistance}""" + "\n" +
@"    }" + "\n" +
@"  }," + "\n" +
@"  ""type"": ""MAP""," + "\n" +
@"  ""default"": {" + "\n" +
@"    ""result"": {" + "\n" +
@"      ""level"": ""LOW""" + "\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}}/riskPredictors"
  method := "POST"

  payload := strings.NewReader(`{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}`)

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

{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"Device Network Location\",\n  \"compactName\": \"deviceNetworkLocation\",\n  \"map\": {\n    \"high\": {\n      \"between\": {\n        \"minScore\": 804672,\n        \"maxScore\": 12742000\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"medium\": {\n      \"between\": {\n        \"minScore\": 321869,\n        \"maxScore\": 804672\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"low\": {\n      \"between\": {\n        \"minScore\": 0,\n        \"maxScore\": 321869\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    }\n  },\n  \"type\": \"MAP\",\n  \"default\": {\n    \"result\": {\n      \"level\": \"LOW\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/v1/environments/{{envID}}/riskPredictors")
  .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}}/riskPredictors",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "name": "Device Network Location",
    "compactName": "deviceNetworkLocation",
    "map": {
      "high": {
        "between": {
          "minScore": 804672,
          "maxScore": 12742000
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "medium": {
        "between": {
          "minScore": 321869,
          "maxScore": 804672
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "low": {
        "between": {
          "minScore": 0,
          "maxScore": 321869
        },
        "contains": "${details.device.estimatedDistance}"
      }
    },
    "type": "MAP",
    "default": {
      "result": {
        "level": "LOW"
      }
    }
  }),
};

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

```javascript
var request = require('request');
var options = {
  'method': 'POST',
  'url': '{{apiPath}}/v1/environments/{{envID}}/riskPredictors',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "name": "Device Network Location",
    "compactName": "deviceNetworkLocation",
    "map": {
      "high": {
        "between": {
          "minScore": 804672,
          "maxScore": 12742000
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "medium": {
        "between": {
          "minScore": 321869,
          "maxScore": 804672
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "low": {
        "between": {
          "minScore": 0,
          "maxScore": 321869
        },
        "contains": "${details.device.estimatedDistance}"
      }
    },
    "type": "MAP",
    "default": {
      "result": {
        "level": "LOW"
      }
    }
  })

};
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}}/riskPredictors"

payload = json.dumps({
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
})
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}}/riskPredictors');
$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": "Device Network Location",\n  "compactName": "deviceNetworkLocation",\n  "map": {\n    "high": {\n      "between": {\n        "minScore": 804672,\n        "maxScore": 12742000\n      },\n      "contains": "${details.device.estimatedDistance}"\n    },\n    "medium": {\n      "between": {\n        "minScore": 321869,\n        "maxScore": 804672\n      },\n      "contains": "${details.device.estimatedDistance}"\n    },\n    "low": {\n      "between": {\n        "minScore": 0,\n        "maxScore": 321869\n      },\n      "contains": "${details.device.estimatedDistance}"\n    }\n  },\n  "type": "MAP",\n  "default": {\n    "result": {\n      "level": "LOW"\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}}/riskPredictors")

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": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "\${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "\${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "\${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
})

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

```swift
let parameters = "{\n  \"name\": \"Device Network Location\",\n  \"compactName\": \"deviceNetworkLocation\",\n  \"map\": {\n    \"high\": {\n      \"between\": {\n        \"minScore\": 804672,\n        \"maxScore\": 12742000\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"medium\": {\n      \"between\": {\n        \"minScore\": 321869,\n        \"maxScore\": 804672\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"low\": {\n      \"between\": {\n        \"minScore\": 0,\n        \"maxScore\": 321869\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    }\n  },\n  \"type\": \"MAP\",\n  \"default\": {\n    \"result\": {\n      \"level\": \"LOW\"\n    }\n  }\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "{{apiPath}}/v1/environments/{{envID}}/riskPredictors")!,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.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/riskPredictors/30674bdd-9304-4574-a0e7-d4865bb72b42"
        },
        "environment": {
            "href": "https://api.pingone.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
        }
    },
    "id": "30674bdd-9304-4574-a0e7-d4865bb72b42",
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    },
    "createdAt": "2023-07-18T13:28:14.971Z",
    "updatedAt": "2023-07-18T13:28:14.971Z",
    "name": "Device Network Location",
    "compactName": "deviceNetworkLocation",
    "licensed": true,
    "deletable": true,
    "map": {
        "high": {
            "between": {
                "minScore": 804672,
                "maxScore": 12742000
            },
            "contains": "${details.device.estimatedDistance}",
            "type": "RANGE"
        },
        "medium": {
            "between": {
                "minScore": 321869,
                "maxScore": 804672
            },
            "contains": "${details.device.estimatedDistance}",
            "type": "RANGE"
        },
        "low": {
            "between": {
                "minScore": 0,
                "maxScore": 321869
            },
            "contains": "${details.device.estimatedDistance}",
            "type": "RANGE"
        }
    },
    "type": "MAP",
    "condition": {
        "scores": [
            {
                "name": "HIGH",
                "value": "HIGH"
            },
            {
                "name": "MEDIUM",
                "value": "MEDIUM"
            },
            {
                "name": "LOW",
                "value": "LOW"
            }
        ]
    },
    "default": {
        "weight": 5,
        "score": 50,
        "result": {
            "level": "LOW",
            "type": "VALUE"
        },
        "evaluated": false
    }
}
```
