RuleSets

RuleSets - DQE One Standalone API

Importieren, exportieren und lesen Sie die Deduplizierungs-RuleSets, auf die sich check_duplicate-Processes stützen.

{DOMAIN} ist der Hostname Ihres eigenen DQE One Standalone Servers — er wird selbst gehostet, daher hängt dieser Wert von Ihrer Bereitstellung ab. {EMAIL} ist Ihr DQE One Login und {API_TOKEN} der Token, der unter My Account > API Token generiert wird.

Zugehörige Dokumentation: DQE One Standalone API — Introduction, Files, Credentials, Processes, Runs & results, RuleSets.
Wie Sie ein RuleSet visuell erstellen, lesen Sie unter Configure a RuleSet in DQE One Standalone.

Zwei verschiedene IDs. Jedes RuleSet hat eine numerische id und eine zeichenfolgenbasierte setId. createProcess erwartet die numerische ID in ruleSet; getRuleset erwartet die Zeichenfolge in set_id; und in einem check_duplicate-Process ist der Schlüssel von fields die Zeichenfolge setId. Beide stammen aus listRulesets.

Direkt zulistRulesets getRuleset exportRulesets importRuleset

RuleSets auflisten - DQE One Standalone API

Listet Ihre RuleSets auf, die zuletzt aktualisierten zuerst.

listRulesets

Direkt zu Parameter Antwort Beispiel Fehler ▶ API testen

Anfrage

Senden Sie eine GET-Anfrage. Es gibt keine Parameter.

GEThttps://{DOMAIN}/api/Ruleset/list

Codebeispiele

Ihre RuleSets auflisten

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                curl -u "{EMAIL}:{API_TOKEN}" \
                "https://{DOMAIN}/api/Ruleset/list"
              

                fetch("https://{DOMAIN}/api/Ruleset/list", {
                method: "GET",
                headers: {
                "Authorization": "Basic " + btoa("{EMAIL}:{API_TOKEN}")
                }
                })
                .then(r => r.text())
                .then(data => console.log(data));
              

                import requests

                response = requests.get(
                "https://{DOMAIN}/api/Ruleset/list",
                auth=("{EMAIL}", "{API_TOKEN}"),
                )
                print(response.status_code, response.text)
              

                <?php
                $ch = curl_init("https://{DOMAIN}/api/Ruleset/list");
                curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
                curl_setopt($ch, CURLOPT_USERPWD, "{EMAIL}:{API_TOKEN}");
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                $response = curl_exec($ch);
                $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                curl_close($ch);
                echo $status . " " . $response;
              

                const axios = require('axios');

                axios({
                method: "get",
                url: "https://{DOMAIN}/api/Ruleset/list",
                auth: { username: "{EMAIL}", password: "{API_TOKEN}"
                }
                })
                .then(res => console.log(res.status, res.data))
                .catch(err => console.log(err.response ? err.response.status
                : err.message, err.response && err.response.data));
              

                import java.net.URI;
                import java.net.http.*;
                import java.util.Base64;

                String auth = Base64.getEncoder().encodeToString("{EMAIL}:{API_TOKEN}".getBytes());

                HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://{DOMAIN}/api/Ruleset/list"))
                .header("Authorization", "Basic " + auth)
                .method("GET", HttpRequest.BodyPublishers.noBody())
                .build();

                HttpResponse<String> response = HttpClient.newHttpClient().send(request,
                HttpResponse.BodyHandlers.ofString());
                System.out.println(response.statusCode() + " " +
                response.body());
              

                using System.Net.Http;
                using System.Net.Http.Headers;
                using System.Text;

                using var client = new HttpClient();
                client.DefaultRequestHeaders.Authorization = new
                AuthenticationHeaderValue(
                "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("{EMAIL}:{API_TOKEN}")));

                using var request = new HttpRequestMessage(HttpMethod.Get,
                "https://{DOMAIN}/api/Ruleset/list");

                var response = await client.SendAsync(request);
                Console.WriteLine((int)response.StatusCode + " "
                + await response.Content.ReadAsStringAsync());
              

                package main

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

                func main() {

                req, _ := http.NewRequest("GET", "https://{DOMAIN}/api/Ruleset/list",
                nil)
                req.SetBasicAuth("{EMAIL}", "{API_TOKEN}")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                panic(err)
                }
                defer resp.Body.Close()

                out, _ := io.ReadAll(resp.Body)
                fmt.Println(resp.StatusCode, string(out))
                }
              

Parameter

Dieser Endpoint benötigt keine Parameter.

Authentifizierung: HTTP Basic — Ihre DQE One E-Mail-Adresse und Ihr API token (My Account > API Token). Siehe den Artikel Introduction.

Antwort

Array. HTTP-Status 200.

Der Body ist ein JSON-Array; jedes Element enthält diese Schlüssel.

Schlüssel	Beschreibung	Typ
id	Numerische ID - das erwartet /api/Process/create in 'ruleSet'.	Integer
setId	Zeichenfolgen-ID - das erwartet /api/Ruleset/get in 'set_id'.	String
label		String
updatedOn		String
source		String

Antwortbeispiel

Beispielantwort

              [
              {
              "id": 7,
              "setId":
              "RS_ABC",
              "label":
              "Contacts email+name",
              "updatedOn":
              "2026-11-01T10:00:00Z",
              "source":
              "postgres"
              }
              ]
            

Fehler

HTTP	Body / Bedeutung
401	`Unauthorized`

API testen

Klicken Sie auf die Schaltfläche unten, um diesen Endpoint live in Ihrem Browser zu testen.

Hinweis: Diese Konsole sendet aus Ihrem Browser eine echte Anfrage an Ihren eigenen Server, mit Ihrem echten API token.

Konsole öffnen

API-Konsole GET /api/Ruleset/list

Server-Domain

Authentifizierung (HTTP Basic)

E-Mail erforderlich

API token erforderlich

Parameter

Keine Parameter.

cURLJSPythonPHPNodeJavaC#Go

RuleSet abrufen - DQE One Standalone API

Gibt die vollständige Definition eines RuleSets zurück, einschließlich der Bezeichnungen der Matching-Regeln, die Sie für einen check_duplicate-Process benötigen.

getRuleset

Direkt zu Parameter Antwort Beispiel Fehler ▶ API testen

Anfrage

Senden Sie eine GET-Anfrage mit der set_id als Zeichenfolge.

Wo die Bezeichnungen stehen: Die Werte in matching.Labels[].value sind das, was Sie beim Erstellen des Process in fields angeben, z. B. {"RS_ABC": ["Email + Name"]}.

GEThttps://{DOMAIN}/api/Ruleset/get?set_id={set_id}

Codebeispiele

RuleSet abrufen

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                curl -u "{EMAIL}:{API_TOKEN}" \
                "https://{DOMAIN}/api/Ruleset/get?set_id=RS_ABC"
              

                fetch("https://{DOMAIN}/api/Ruleset/get?set_id=RS_ABC",
                {
                method: "GET",
                headers: {
                "Authorization": "Basic " + btoa("{EMAIL}:{API_TOKEN}")
                }
                })
                .then(r => r.text())
                .then(data => console.log(data));
              

                import requests

                response = requests.get(
                "https://{DOMAIN}/api/Ruleset/get",
                auth=("{EMAIL}", "{API_TOKEN}"),
                params={"set_id": "RS_ABC"},
                )
                print(response.status_code, response.text)
              

                <?php
                $ch = curl_init("https://{DOMAIN}/api/Ruleset/get?set_id=RS_ABC");
                curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
                curl_setopt($ch, CURLOPT_USERPWD, "{EMAIL}:{API_TOKEN}");
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                $response = curl_exec($ch);
                $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                curl_close($ch);
                echo $status . " " . $response;
              

                const axios = require('axios');

                axios({
                method: "get",
                url: "https://{DOMAIN}/api/Ruleset/get",
                auth: { username: "{EMAIL}", password: "{API_TOKEN}"
                },
                params: { "set_id": "RS_ABC" }
                })
                .then(res => console.log(res.status, res.data))
                .catch(err => console.log(err.response ? err.response.status
                : err.message, err.response && err.response.data));
              

                import java.net.URI;
                import java.net.http.*;
                import java.util.Base64;

                String auth = Base64.getEncoder().encodeToString("{EMAIL}:{API_TOKEN}".getBytes());

                HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://{DOMAIN}/api/Ruleset/get?set_id=RS_ABC"))
                .header("Authorization", "Basic " + auth)
                .method("GET", HttpRequest.BodyPublishers.noBody())
                .build();

                HttpResponse<String> response = HttpClient.newHttpClient().send(request,
                HttpResponse.BodyHandlers.ofString());
                System.out.println(response.statusCode() + " " +
                response.body());
              

                using System.Net.Http;
                using System.Net.Http.Headers;
                using System.Text;

                using var client = new HttpClient();
                client.DefaultRequestHeaders.Authorization = new
                AuthenticationHeaderValue(
                "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("{EMAIL}:{API_TOKEN}")));

                using var request = new HttpRequestMessage(HttpMethod.Get,
                "https://{DOMAIN}/api/Ruleset/get?set_id=RS_ABC");

                var response = await client.SendAsync(request);
                Console.WriteLine((int)response.StatusCode + " "
                + await response.Content.ReadAsStringAsync());
              

                package main

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

                func main() {

                req, _ := http.NewRequest("GET", "https://{DOMAIN}/api/Ruleset/get?set_id=RS_ABC",
                nil)
                req.SetBasicAuth("{EMAIL}", "{API_TOKEN}")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                panic(err)
                }
                defer resp.Body.Close()

                out, _ := io.ReadAll(resp.Body)
                fmt.Println(resp.StatusCode, string(out))
                }
              

Parameter

Feld	Beschreibung	Typ	Pflicht / Opt.
set_id	Die `setId`-Zeichenfolge aus der Liste.	String	Pflicht

Authentifizierung: HTTP Basic — Ihre DQE One E-Mail-Adresse und Ihr API token (My Account > API Token). Siehe den Artikel Introduction.

Antwort

RuleSet. HTTP-Status 200.

Schlüssel	Beschreibung	Typ
setId		String
isEditable		Boolean
label		String
updatedOn		String
source		String
matching		Object
filtering		Object
parenting		Object
merging		Object
objectsNames		Array
multiobjectsMapping		Object
isPublished		Boolean

Antwortbeispiel

Die Antwort ist ein Dateianhang, kein JSON.

Fehler

HTTP	Body / Bedeutung
400	`set_id parameter is required`
401	`Unauthorized`
404	`RuleSet not found`

API testen

Klicken Sie auf die Schaltfläche unten, um diesen Endpoint live in Ihrem Browser zu testen.

Hinweis: Diese Konsole sendet aus Ihrem Browser eine echte Anfrage an Ihren eigenen Server, mit Ihrem echten API token.

Konsole öffnen

API-Konsole GET /api/Ruleset/get

Server-Domain

Authentifizierung (HTTP Basic)

E-Mail erforderlich

API token erforderlich

Parameter

set_id erforderlich

cURLJSPythonPHPNodeJavaC#Go

RuleSets exportieren - DQE One Standalone API

Lädt alle Ihre RuleSets als eine JSON-Datei herunter, die nach set_id geordnet ist. Es gibt keinen Filter und keine Paginierung.

exportRulesets

Direkt zu Parameter Antwort Beispiel Fehler ▶ API testen

Anfrage

Senden Sie eine GET-Anfrage. Die Antwort ist ein JSON-Dateianhang.

GEThttps://{DOMAIN}/api/Ruleset/export

Codebeispiele

Alle Ihre RuleSets exportieren

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                curl -u "{EMAIL}:{API_TOKEN}" \
                "https://{DOMAIN}/api/Ruleset/export"
              

                fetch("https://{DOMAIN}/api/Ruleset/export", {
                method: "GET",
                headers: {
                "Authorization": "Basic " + btoa("{EMAIL}:{API_TOKEN}")
                }
                })
                .then(r => r.text())
                .then(data => console.log(data));
              

                import requests

                response = requests.get(
                "https://{DOMAIN}/api/Ruleset/export",
                auth=("{EMAIL}", "{API_TOKEN}"),
                )
                print(response.status_code, response.text)
              

                <?php
                $ch = curl_init("https://{DOMAIN}/api/Ruleset/export");
                curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
                curl_setopt($ch, CURLOPT_USERPWD, "{EMAIL}:{API_TOKEN}");
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                $response = curl_exec($ch);
                $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                curl_close($ch);
                echo $status . " " . $response;
              

                const axios = require('axios');

                axios({
                method: "get",
                url: "https://{DOMAIN}/api/Ruleset/export",
                auth: { username: "{EMAIL}", password: "{API_TOKEN}"
                }
                })
                .then(res => console.log(res.status, res.data))
                .catch(err => console.log(err.response ? err.response.status
                : err.message, err.response && err.response.data));
              

                import java.net.URI;
                import java.net.http.*;
                import java.util.Base64;

                String auth = Base64.getEncoder().encodeToString("{EMAIL}:{API_TOKEN}".getBytes());

                HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://{DOMAIN}/api/Ruleset/export"))
                .header("Authorization", "Basic " + auth)
                .method("GET", HttpRequest.BodyPublishers.noBody())
                .build();

                HttpResponse<String> response = HttpClient.newHttpClient().send(request,
                HttpResponse.BodyHandlers.ofString());
                System.out.println(response.statusCode() + " " +
                response.body());
              

                using System.Net.Http;
                using System.Net.Http.Headers;
                using System.Text;

                using var client = new HttpClient();
                client.DefaultRequestHeaders.Authorization = new
                AuthenticationHeaderValue(
                "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("{EMAIL}:{API_TOKEN}")));

                using var request = new HttpRequestMessage(HttpMethod.Get,
                "https://{DOMAIN}/api/Ruleset/export");

                var response = await client.SendAsync(request);
                Console.WriteLine((int)response.StatusCode + " "
                + await response.Content.ReadAsStringAsync());
              

                package main

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

                func main() {

                req, _ := http.NewRequest("GET", "https://{DOMAIN}/api/Ruleset/export",
                nil)
                req.SetBasicAuth("{EMAIL}", "{API_TOKEN}")

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                panic(err)
                }
                defer resp.Body.Close()

                out, _ := io.ReadAll(resp.Body)
                fmt.Println(resp.StatusCode, string(out))
                }
              

Parameter

Dieser Endpoint benötigt keine Parameter.

Authentifizierung: HTTP Basic — Ihre DQE One E-Mail-Adresse und Ihr API token (My Account > API Token). Siehe den Artikel Introduction.

Antwort

JSON-Anhang. HTTP-Status 200.

Binäre Antwort bzw. Anhang (application/octet-stream).

Antwortbeispiel

Die Antwort ist ein Dateianhang, kein JSON.

Fehler

HTTP	Body / Bedeutung
401	`Unauthorized`

API testen

Klicken Sie auf die Schaltfläche unten, um diesen Endpoint live in Ihrem Browser zu testen.

Hinweis: Diese Konsole sendet aus Ihrem Browser eine echte Anfrage an Ihren eigenen Server, mit Ihrem echten API token.

Konsole öffnen

API-Konsole GET /api/Ruleset/export

Server-Domain

Authentifizierung (HTTP Basic)

E-Mail erforderlich

API token erforderlich

Parameter

Keine Parameter.

cURLJSPythonPHPNodeJavaC#Go

RuleSets importieren - DQE One Standalone API

Importiert ein oder mehrere RuleSets aus einer JSON-Datei im Exportformat.

importRuleset

Direkt zu Parameter Antwort Beispiel Fehler ▶ API testen

Anfrage

Senden Sie einen multipart/form-data-POST mit einem Feld namens file (eine .json-Datei).

Zu beachtendes Verhalten: Regeln mit benutzerdefiniertem Code (eine Regel mit einem Definition-Schlüssel oder Custom: true) werden abgelehnt. Ein vorhandenes bearbeitbares RuleSet mit derselben set_id wird überschrieben. Eine Datei kann teilweise erfolgreich sein: Sie erhalten dann partial success mit der Liste der Fehler. Wenn alle RuleSets fehlschlagen, lautet der Status 500 und error ist eine Liste (anders als bei allen anderen Endpoints, wo es eine Zeichenfolge ist). Ein RuleSet, das auf eine Datei oder ein Credential verweist, muss auf ein vorhandenes verweisen.

POSThttps://{DOMAIN}/api/Ruleset/import

Codebeispiele

RuleSets importieren

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                curl -u "{EMAIL}:{API_TOKEN}" -X POST \
                -F "file=@rulesets.json" \
                "https://{DOMAIN}/api/Ruleset/import"
              

                const form = new FormData();
                form.append("file", fileInput.files[0]); // <input
                type="file">

                fetch("https://{DOMAIN}/api/Ruleset/import", {
                method: "POST",
                headers: {
                "Authorization": "Basic " + btoa("{EMAIL}:{API_TOKEN}")
                },
                body: form
                })
                .then(r => r.text())
                .then(data => console.log(data));
              

                import requests

                response = requests.post(
                "https://{DOMAIN}/api/Ruleset/import",
                auth=("{EMAIL}", "{API_TOKEN}"),
                files={"file": open("rulesets.json", "rb")},
                )
                print(response.status_code, response.text)
              

                <?php
                $ch = curl_init("https://{DOMAIN}/api/Ruleset/import");
                curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
                curl_setopt($ch, CURLOPT_USERPWD, "{EMAIL}:{API_TOKEN}");
                curl_setopt($ch, CURLOPT_POSTFIELDS, ['file' =>
                new CURLFile("rulesets.json")]);
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
                $response = curl_exec($ch);
                $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
                curl_close($ch);
                echo $status . " " . $response;
              

                const axios = require('axios');
                const FormData = require('form-data');
                const fs = require('fs');

                const form = new FormData();
                form.append('file', fs.createReadStream("rulesets.json"));

                axios({
                method: "post",
                url: "https://{DOMAIN}/api/Ruleset/import",
                auth: { username: "{EMAIL}", password: "{API_TOKEN}"
                },
                headers: form.getHeaders(),
                data: form
                })
                .then(res => console.log(res.status, res.data))
                .catch(err => console.log(err.response ? err.response.status
                : err.message, err.response && err.response.data));
              

                import java.net.URI;
                import java.net.http.*;
                import java.util.Base64;

                String auth = Base64.getEncoder().encodeToString("{EMAIL}:{API_TOKEN}".getBytes());
                String boundary = "----dqe" + System.nanoTime();
                byte[] content = java.nio.file.Files.readAllBytes(java.nio.file.Path.of("rulesets.json"));
                var out = new java.io.ByteArrayOutputStream();
                out.write(("--" + boundary + "\r\nContent-Disposition:
                form-data; name=\"file\"; filename=\"" + "rulesets.json"
                + "\"\r\n\r\n").getBytes());
                out.write(content);
                out.write(("\r\n--" + boundary + "--\r\n").getBytes());

                HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://{DOMAIN}/api/Ruleset/import"))
                .header("Authorization", "Basic " + auth)
                .header("Content-Type", "multipart/form-data; boundary="
                + boundary)
                .method("POST", HttpRequest.BodyPublishers.ofByteArray(out.toByteArray()))
                .build();

                HttpResponse<String> response = HttpClient.newHttpClient().send(request,
                HttpResponse.BodyHandlers.ofString());
                System.out.println(response.statusCode() + " " +
                response.body());
              

                using System.Net.Http;
                using System.Net.Http.Headers;
                using System.Text;

                using var client = new HttpClient();
                client.DefaultRequestHeaders.Authorization = new
                AuthenticationHeaderValue(
                "Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes("{EMAIL}:{API_TOKEN}")));

                using var request = new HttpRequestMessage(HttpMethod.Post,
                "https://{DOMAIN}/api/Ruleset/import");
                var form = new MultipartFormDataContent();
                form.Add(new ByteArrayContent(File.ReadAllBytes("rulesets.json")),
                "file", "rulesets.json");
                request.Content = form;

                var response = await client.SendAsync(request);
                Console.WriteLine((int)response.StatusCode + " "
                + await response.Content.ReadAsStringAsync());
              

                package main

                import (
                "bytes"
                "fmt"
                "io"
                "mime/multipart"
                "net/http"
                "os"
                )

                func main() {
                var buf bytes.Buffer
                w := multipart.NewWriter(&buf)
                part, _ := w.CreateFormFile("file", "rulesets.json")
                f, _ := os.Open("rulesets.json")
                io.Copy(part, f)
                w.Close()

                req, _ := http.NewRequest("POST", "https://{DOMAIN}/api/Ruleset/import",
                &buf)
                req.SetBasicAuth("{EMAIL}", "{API_TOKEN}")
                req.Header.Set("Content-Type", w.FormDataContentType())

                resp, err := http.DefaultClient.Do(req)
                if err != nil {
                panic(err)
                }
                defer resp.Body.Close()

                out, _ := io.ReadAll(resp.Body)
                fmt.Println(resp.StatusCode, string(out))
                }
              

Parameter

Feld	Beschreibung	Typ	Pflicht / Opt.
file	Ein `.json`-RuleSet-Export.	String (file)	Pflicht

Authentifizierung: HTTP Basic — Ihre DQE One E-Mail-Adresse und Ihr API token (My Account > API Token). Siehe den Artikel Introduction.

Antwort

Importiert (success oder partial success). HTTP-Status 200.

Schlüssel	Beschreibung	Typ
status	Werte: `success`, `partial success`, `error`	String
id		Array
error	Hier eine LISTE (anders als bei allen anderen Endpoints).	Array

Antwortbeispiel

Beispielantwort

Fehler

HTTP	Body / Bedeutung
400	`API only accept .json file.`
401	`Unauthorized`
500

API testen

Klicken Sie auf die Schaltfläche unten, um diesen Endpoint live in Ihrem Browser zu testen.

Hinweis: Diese Konsole sendet aus Ihrem Browser eine echte Anfrage an Ihren eigenen Server, mit Ihrem echten API token. Dadurch werden echte RuleSets erstellt oder überschrieben.

Konsole öffnen

API-Konsole POST /api/Ruleset/import

Server-Domain

Authentifizierung (HTTP Basic)

E-Mail erforderlich

API token erforderlich

Parameter

file erforderlich

cURLJSPythonPHPNodeJavaC#Go

RuleSets

listRulesets

Anfrage

Codebeispiele

Parameter

Antwort

Antwortbeispiel

Fehler

API testen

getRuleset

Anfrage

Codebeispiele

Parameter

Antwort

Antwortbeispiel

Fehler

API testen

exportRulesets

Anfrage

Codebeispiele

Parameter

Antwort

Antwortbeispiel

Fehler

API testen

importRuleset

Anfrage

Codebeispiele

Parameter

Antwort

Antwortbeispiel

Fehler

API testen

Siehe auch

War dieser Beitrag hilfreich?

Vorheriger Artikel

Nächster Artikel