Rules

List the signals a rule can read

Beta. The request and response shapes may still change.

List the Prelude signals a rule expression may reference. A signal is a name Prelude resolves for the evaluation being scored, and it means the same thing for every customer. Write it in an expression and compare it like any other value of its type.

Prelude provides these names. The rest of a rule’s vocabulary is yours - the attr. names a recipe declares and the param. names it is configured with - and those do not appear here.

A signal may be absent from an evaluation, whatever its type. A rule that reads a signal that did not arrive reports NOT_EVALUATED rather than treating the missing value as a zero.

Prelude publishes the catalog progressively, so this listing grows over time. Write rules against what it returns: a signal it does not list is one Prelude has not committed to, and it can change or be removed without notice.

GET

watch

management

rules

catalog

List signals

curl --request GET \
  --url https://api.prelude.dev/v2/watch/management/rules/catalog \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.prelude.dev/v2/watch/management/rules/catalog', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.prelude.dev/v2/watch/management/rules/catalog",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.prelude.dev/v2/watch/management/rules/catalog"

	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(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.prelude.dev/v2/watch/management/rules/catalog")

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

{
  "signals": [
    {
      "name": "ip",
      "type": "bool",
      "description": "The end user's IP address: the one sent with the evaluation request, or the one the Prelude SDK collected."
    }
  ],
  "next_cursor": "hardware_manufacturer"
}

{
  "code": "invalid_phone_number",
  "message": "The provided phone number is invalid. Provide a valid E.164 phone number.",
  "type": "bad_request",
  "request_id": "3d19215e-2991-4a05-a41a-527314e6ff6a",
  "param": "phone_number"
}

A signal is a name Prelude resolves for the evaluation being scored: a fact about the request, the device, or the number that Prelude determines for you. Every customer gets the same signals, and each one means the same thing for all of them.

Your own values are separate

A rule can also read the attr. names a recipe declares and the param. names it is configured with. Those belong to you, they exist only in the recipe that declares them, and they are not listed here.

An absent signal is not a zero

Any signal can be missing from a given evaluation. A rule that reads a signal that did not arrive reports NOT_EVALUATED instead of scoring. It does not read the absence as false, as 0, or as an empty string. Write the condition you mean, and let the engine report the absence.

The listing grows

Prelude publishes the catalog progressively, so this listing grows over time. Treat it as the supported vocabulary: a signal it does not list is one Prelude has not committed to, so read it rather than keeping a copy.

Authorizations

Authorization

string

header

required

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

Query Parameters

limit

integer

default:50

Maximum number of signals to return per page. A larger value is clamped to 200 rather than refused.

Required range: 1 <= x <= 200

cursor

string

Pagination cursor from the previous response.

Response

signals

object[]

required

Show child attributes

next_cursor

string

Pass this back as cursor for the next page. Absent on the last page.

Example:

"hardware_manufacturer"

List signals

curl --request GET \
  --url https://api.prelude.dev/v2/watch/management/rules/catalog \
  --header 'Authorization: Bearer <token>'

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.prelude.dev/v2/watch/management/rules/catalog', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.prelude.dev/v2/watch/management/rules/catalog",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

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

func main() {

	url := "https://api.prelude.dev/v2/watch/management/rules/catalog"

	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(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.prelude.dev/v2/watch/management/rules/catalog")

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

{
  "signals": [
    {
      "name": "ip",
      "type": "bool",
      "description": "The end user's IP address: the one sent with the evaluation request, or the one the Prelude SDK collected."
    }
  ],
  "next_cursor": "hardware_manufacturer"
}

{
  "code": "invalid_phone_number",
  "message": "The provided phone number is invalid. Provide a valid E.164 phone number.",
  "type": "bad_request",
  "request_id": "3d19215e-2991-4a05-a41a-527314e6ff6a",
  "param": "phone_number"
}

Documentation

API Reference

Management API

List the signals a rule can read

Your own values are separate

An absent signal is not a zero

The listing grows

Authorizations

Query Parameters

Response

​Your own values are separate

​An absent signal is not a zero

​The listing grows

Authorizations

Query Parameters

Response

Your own values are separate

An absent signal is not a zero

The listing grows