Retrieve a reconciliation rule

curl --request GET \
  --url https://api.endclose.com/v1/reconciliation_rules/{id} \
  --header 'X-API-KEY: <api-key>'

const options = {method: 'GET', headers: {'X-API-KEY': '<api-key>'}};

fetch('https://api.endclose.com/v1/reconciliation_rules/{id}', 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.endclose.com/v1/reconciliation_rules/{id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-API-KEY: <api-key>"
  ],
]);

$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.endclose.com/v1/reconciliation_rules/{id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-API-KEY", "<api-key>")

	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.endclose.com/v1/reconciliation_rules/{id}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-API-KEY"] = '<api-key>'

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

{
  "filters": {
    "operand": "and",
    "rules": [
      {
        "key": "<string>",
        "operand": "eq",
        "value": "<string>",
        "tolerance_amount": 123,
        "tolerance_unit": "dollar",
        "transforms": {
          "key": "<unknown>",
          "value": "<unknown>"
        }
      }
    ]
  },
  "reconciliation_id": 123,
  "id": 123,
  "priority": 123,
  "group_by": [
    "<string>"
  ],
  "cardinality": "one_to_one",
  "rollup": {
    "lookback_days": 2,
    "date_field": "<string>",
    "group_by_kind": "date"
  },
  "description": "<string>",
  "source": "user",
  "status": "active",
  "confidence": "high",
  "sample_match_rate": "<string>",
  "created_at": "2023-11-07T05:31:56Z"
}

GET

reconciliation_rules

{id}

Retrieve a reconciliation rule

curl --request GET \
  --url https://api.endclose.com/v1/reconciliation_rules/{id} \
  --header 'X-API-KEY: <api-key>'

const options = {method: 'GET', headers: {'X-API-KEY': '<api-key>'}};

fetch('https://api.endclose.com/v1/reconciliation_rules/{id}', 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.endclose.com/v1/reconciliation_rules/{id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "X-API-KEY: <api-key>"
  ],
]);

$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.endclose.com/v1/reconciliation_rules/{id}"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-API-KEY", "<api-key>")

	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.endclose.com/v1/reconciliation_rules/{id}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-API-KEY"] = '<api-key>'

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

{
  "filters": {
    "operand": "and",
    "rules": [
      {
        "key": "<string>",
        "operand": "eq",
        "value": "<string>",
        "tolerance_amount": 123,
        "tolerance_unit": "dollar",
        "transforms": {
          "key": "<unknown>",
          "value": "<unknown>"
        }
      }
    ]
  },
  "reconciliation_id": 123,
  "id": 123,
  "priority": 123,
  "group_by": [
    "<string>"
  ],
  "cardinality": "one_to_one",
  "rollup": {
    "lookback_days": 2,
    "date_field": "<string>",
    "group_by_kind": "date"
  },
  "description": "<string>",
  "source": "user",
  "status": "active",
  "confidence": "high",
  "sample_match_rate": "<string>",
  "created_at": "2023-11-07T05:31:56Z"
}

Authorizations

X-API-KEY

string

header

required

Path Parameters

string

required

Response

Rule retrieved

filters

object

required

A rule tree with group nodes (AND/OR) and condition leaf nodes. Conditions compare a field on one side to a field on the other side. On a many_to_one rule only AND-combined eq conditions without tolerances are accepted: amount eq amount is satisfied by the rollup itself (the group total is compared to the Side B amount), and every other condition segments the Side A groups by its key and requires the Side B record to carry the same value in its value field (for example metadata.operator eq metadata.operator keeps each operator's batches with that operator's payout). OR groups, other operands and tolerances are rejected on many_to_one rules.

Show child attributes

reconciliation_id

integer

required

integer

priority

integer

Lower values run first

group_by

string[]

Side A field keys to group records by before matching. The first key is the primary axis: in rollup.group_by_kind 'date' mode it must be a date field; in 'identifier' mode it can be any field (e.g. a batch id in metadata). Additional keys further segment Side A — in date mode each segment matches only Side B records with the same value for those fields; in identifier mode they form a composite cohort key and do not constrain the Side B record. To require the Side B record to share a value in either mode, add an eq condition to filters.

cardinality

enum<string>

default:one_to_one

Match cardinality. 'one_to_one' matches single records on each side. 'many_to_one' rolls up multiple records on one side to match a single record on the other side — requires the rollup field to be set.

Available options:

one_to_one,

many_to_one

rollup

object | null

Required when cardinality is 'many_to_one'. Configures how records on the many side are aggregated before matching.

Show child attributes

description

string

Optional human-readable description of what this rule matches

source

enum<string>

Origin of the rule. 'user' = created manually via the API or UI. 'ai' = created by the AI rules engine. 'default' = built-in rule seeded on older reconciliations (no longer created).

Available options:

user,

ai,

default

status

enum<string>

Active rules are used by the reconciliation engine. Proposed rules are awaiting review from a cold start.

Available options:

active,

proposed

confidence

enum<string>

AI confidence rating. Only present on AI-generated rules from cold start.

Available options:

high,

medium,

low

sample_match_rate

string

How many sample records this rule matched during dry-run evaluation (e.g. '42/50'). Only present on AI-generated rules from cold start.

created_at

string<date-time>

Resources

Webhooks

Retrieve a reconciliation rule

Authorizations

Path Parameters

Response