Processes - DQE One Standalone API
Erstellen, aktualisieren, starten und löschen Sie Data-Quality-Processes auf Ihrem selbst gehosteten DQE One Standalone Server. Ein Process verknüpft eine Datenquelle (eine CSV-Datei, eine Datenbank oder ein CRM) mit einer Aktion, etwa der Prüfung von E-Mail-Adressen, Telefonnummern, Adressen, Namen oder Unternehmen oder der Suche nach Duplikaten.
{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.
Typische Reihenfolge: eine Datei hochladen
(Files)
oder ein Credential erstellen (Credentials)
→
Zugehörige Dokumentation: DQE One Standalone API — Introduction, Files, Credentials, Runs & results, RuleSets.
createProcess → runProcess →
den Run abfragen (Runs)
→ das Ergebnis herunterladen.Zugehörige Dokumentation: DQE One Standalone API — Introduction, Files, Credentials, Runs & results, RuleSets.
Zwei Operationen verändern Daten per GET:
runProcess und deleteProcess sind
GET-Anfragen, obwohl sie einen Run starten bzw.
einen Process löschen. Tragen Sie diese URLs niemals in einen
Crawler, einen Link-Prefetcher oder irgendetwas ein, das
GET-Anfragen wiederholt.
Processes auflisten - DQE One Standalone API
Listet die Processes auf, die Ihnen gehören, in beliebiger Reihenfolge.
listProcesses
Anfrage
Senden Sie eine GET-Anfrage mit Ihren Basic-Zugangsdaten.
Es gibt keine Parameter.
GEThttps://{DOMAIN}/api/Process/list
Codebeispiele
Ihre Processes auflisten
curl -u "{EMAIL}:{API_TOKEN}" \
"https://{DOMAIN}/api/Process/list"
fetch("https://{DOMAIN}/api/Process/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/Process/list",
auth=("{EMAIL}", "{API_TOKEN}"),
)
print(response.status_code, response.text)
<?php
$ch = curl_init("https://{DOMAIN}/api/Process/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/Process/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/Process/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/Process/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/Process/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 | Integer | |
| name | String | |
| type | String | |
| isDraft | Boolean | |
| lastRunId | Integer |
Antwortbeispiel
Beispielantwort
[
{
"id": 42,
"name":
"Email check",
"type":
"check_email",
"isDraft": false,
"lastRunId": 101
}
]
Fehler
| HTTP | Body / Bedeutung |
|---|---|
| 401 |
Unauthorized
|
| 500 |
Unexpected error
|
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
Process abrufen - DQE One Standalone API
Gibt die Details eines Process zurück. Ein Process, der einem anderen Benutzer gehört, wird mit 404 beantwortet.
getProcess
Anfrage
Senden Sie eine GET-Anfrage mit der Process-ID.
Bekanntes Problem: Bei einem Process ohne
verknüpfte Datei (jede Nicht-CSV-Quelle) kann dieser Endpoint
statt mit JSON mit einem unformatierten HTTP 500 antworten.
GEThttps://{DOMAIN}/api/Process/get?id={id}
Codebeispiele
Process abrufen
curl -u "{EMAIL}:{API_TOKEN}" \
"https://{DOMAIN}/api/Process/get?id=42"
fetch("https://{DOMAIN}/api/Process/get?id=42", {
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/Process/get",
auth=("{EMAIL}", "{API_TOKEN}"),
params={"id": "42"},
)
print(response.status_code, response.text)
<?php
$ch = curl_init("https://{DOMAIN}/api/Process/get?id=42");
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/Process/get",
auth: { username: "{EMAIL}", password: "{API_TOKEN}"
},
params: { "id": "42" }
})
.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/Process/get?id=42"))
.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/Process/get?id=42");
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/Process/get?id=42",
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. |
|---|---|---|---|
| id | Process-ID. | Integer | Pflicht |
Authentifizierung: HTTP Basic — Ihre DQE
One E-Mail-Adresse und Ihr API token (My Account > API Token).
Siehe den Artikel Introduction.
Antwort
Process. HTTP-Status 200.
| Schlüssel | Beschreibung | Typ |
|---|---|---|
| id | Integer | |
| name | String | |
| type | Art des Process. | String |
| source | String | |
| description | String | |
| file | Integer | |
| credentials | Integer | |
| ruleSet | Integer | |
| lastRunId | Integer | |
| createdBy | String | |
| updatedBy | String | |
| createdOn | String | |
| updatedOn | String |
Antwortbeispiel
Die Antwort ist ein Dateianhang, kein JSON.
Fehler
| HTTP | Body / Bedeutung |
|---|---|
| 400 |
No id found.
|
| 401 |
Unauthorized
|
| 404 |
Process 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
Process erstellen - DQE One Standalone API
Erstellt einen Process, der sofort ausführbar ist (er wird nicht als Entwurf gespeichert). Die Validierung ist streng und prüft die Live-Quelle, sodass ein falsches Credential, Objekt oder Feld bereits beim Erstellen gemeldet wird.
createProcess
Anfrage
Senden Sie einen JSON-Body. Erforderlich: name,
kind, source, primaryKey
und fields; der Rest hängt von der Quelle und
der Art ab (Tabellen unten).
POSThttps://{DOMAIN}/api/Process/create
Codebeispiele
Process erstellen
curl -u "{EMAIL}:{API_TOKEN}" -X POST \
-H "Content-Type: application/json" \
-d '{
"name": "Email check",
"kind": "check_email",
"source": "csv",
"file": 12,
"primaryKey": "Id",
"fields": {
"FieldLabel": "Email"
}
}' \
"https://{DOMAIN}/api/Process/create"
fetch("https://{DOMAIN}/api/Process/create", {
method: "POST",
headers: {
"Authorization": "Basic " + btoa("{EMAIL}:{API_TOKEN}"),
"Content-Type": "application/json"
},
body: JSON.stringify({
"name": "Email check",
"kind": "check_email",
"source": "csv",
"file": 12,
"primaryKey": "Id",
"fields": {
"FieldLabel": "Email"
}
})
})
.then(r => r.text())
.then(data => console.log(data));
import requests
response = requests.post(
"https://{DOMAIN}/api/Process/create",
auth=("{EMAIL}", "{API_TOKEN}"),
json={"name": "Email check", "kind": "check_email",
"source": "csv", "file": 12, "primaryKey": "Id",
"fields": {"FieldLabel": "Email"}},
)
print(response.status_code, response.text)
<?php
$ch = curl_init("https://{DOMAIN}/api/Process/create");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_USERPWD, "{EMAIL}:{API_TOKEN}");
$data = ['name' => 'Email check', 'kind' =>
'check_email', 'source' => 'csv', 'file' =>
12, 'primaryKey' => 'Id', 'fields' => ['FieldLabel'
=> 'Email']];
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type:
application/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');
axios({
method: "post",
url: "https://{DOMAIN}/api/Process/create",
auth: { username: "{EMAIL}", password: "{API_TOKEN}"
},
data: {
"name": "Email check",
"kind": "check_email",
"source": "csv",
"file": 12,
"primaryKey": "Id",
"fields": {
"FieldLabel": "Email"
}
}
})
.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 body = "{\"name\":\"Email check\",\"kind\":\"check_email\",\"source\":\"csv\",\"file\":12,\"primaryKey\":\"Id\",\"fields\":{\"FieldLabel\":\"Email\"}}";
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://{DOMAIN}/api/Process/create"))
.header("Authorization", "Basic " + auth)
.header("Content-Type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString(body))
.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/Process/create");
request.Content = new StringContent("{\"name\":\"Email
check\",\"kind\":\"check_email\",\"source\":\"csv\",\"file\":12,\"primaryKey\":\"Id\",\"fields\":{\"FieldLabel\":\"Email\"}}",
Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode + " "
+ await response.Content.ReadAsStringAsync());
package main
import (
"bytes"
"fmt"
"io"
"net/http"
)
func main() {
body := []byte(`{"name":"Email check","kind":"check_email","source":"csv","file":12,"primaryKey":"Id","fields":{"FieldLabel":"Email"}}`)
req, _ := http.NewRequest("POST", "https://{DOMAIN}/api/Process/create",
bytes.NewBuffer(body))
req.SetBasicAuth("{EMAIL}", "{API_TOKEN}")
req.Header.Set("Content-Type", "application/json")
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. |
|---|---|---|---|
| name | String | Pflicht | |
| kind |
Werte:
find_and_replace, format,
audit, check_address,
check_b2b, check_email,
check_phone, check_name,
check_duplicate
|
String | Pflicht |
| source |
Werte:
salesforce, dynamics,
postgres, snowflake,
bigquery, sftp,
csv
|
String | Pflicht |
| primaryKey | Muss in den Dateiköpfen bzw. im Quellobjekt vorhanden sein. Bei Salesforce und Dynamics muss es der tatsächliche Primärschlüssel des Objekts sein. | String | Pflicht |
| fields | Aufbau hängt von 'kind' ab - siehe den Artikel Processes ('fields' pro kind). | Object | Pflicht |
| description | String | Optional | |
| file | Nur csv: ID aus /api/File/add. Die Datei wird GEKLONT und mit dem Process verknüpft. | Integer | Optional |
| credential | Jede Quelle außer csv. Der Typ muss zu 'source' passen. | Integer | Optional |
| object | Tabelle / sObject / Entität. Erforderlich für salesforce, dynamics, postgres, snowflake, bigquery. | String | Optional |
| ruleSet | Nur check_duplicate: die numerische 'id' aus /api/Ruleset/list (NICHT die Zeichenfolge setId). | Integer | Optional |
| input_file_path | String | Optional | |
| output_dir_path | String | Optional | |
| reject_dir_path | String | Optional | |
| filters | Liste von Blöcken, jeder eine Liste von Zeilen. [[]] bedeutet kein Filter. | Array | Optional |
| sync |
Standardwert:
false
|
Boolean | Optional |
| allowEmpty |
Standardwert:
false
|
Boolean | Optional |
| autoMerge |
Standardwert:
false
|
Boolean | Optional |
| mergeThreshold |
Standardwert:
100
|
Integer | Optional |
| mergeB2BCode |
Zulässige Elemente:
A+, A,
B+, B, C+,
C, D+, D
|
Array | Optional |
| mergeRNVPCode |
Zulässige Elemente:
10, 20,
21, 22, 23,
24, 25, 30,
31, 40, 41,
50, 51, 60,
61, 70, 71,
80, 81, 90
|
Array | Optional |
| updateChildToInactive |
Standardwert:
false
|
Boolean | Optional |
| deleteSFTP |
Standardwert:
false
|
Boolean | Optional |
| metaToReparent | Object | Optional | |
| next | ID eines Process, der nach diesem verkettet werden soll. | Integer | Optional |
Authentifizierung: HTTP Basic — Ihre DQE
One E-Mail-Adresse und Ihr API token (My Account > API Token).
Siehe den Artikel Introduction.
Das Objekt fields pro kind
Jeder Wert ist der
Name einer Spalte (CSV) bzw. eines Felds (Datenbank/CRM),
die in der Quelle vorhanden sein muss; das gilt auch für
primaryKey.
| kind |
Schlüssel in fields
|
|---|---|
| check_email |
FieldLabel
|
| check_phone |
CountryField, FieldLabel,
Format
|
| check_name |
Salutation, FirstName,
LastName
|
| check_address |
City, Country,
DefaultCountry, FieldTag,
PostalCode, Street;
optional State
|
| check_b2b |
City, CompanyName,
Country, PostalCode,
Siret, Street; optional
State, dazu DQE_<field>-Schlüssel
für die zusätzlichen B2B-Notice-Felder
|
| check_duplicate |
Ein Schlüssel = die Zeichenfolge
setId des RuleSets; sein Wert ist
die Liste der zu verwendenden Bezeichnungen der
Matching-Regeln, die in matching.Labels[].value
des RuleSets enthalten sein müssen (mit
/api/Ruleset/get abrufbar). Beispiel:
{"RS_ABC": ["Email + Name"]}
|
| find_and_replace, format, audit | Derzeit über die API nicht nutzbar — siehe Bekannte Einschränkungen unten. |
Erforderliche Schlüssel pro source
| source | Zusätzlich zu name, kind, source, primaryKey, fields erforderliche Schlüssel |
|---|---|
| salesforce, dynamics, postgres, bigquery |
object, credential
(sein Typ muss zur Quelle passen)
|
| snowflake | Dasselbe, aber Snowflake-Processes scheitern derzeit an der Validierung (siehe Einschränkungen) |
| sftp |
credential, input_file_path,
output_dir_path, reject_dir_path
(die drei Pfade müssen auf dem SFTP-Server existieren)
|
| csv |
file — die von /api/File/add
zurückgegebene ID. Die Datei wird geklont
und der Klon mit dem Process verknüpft; das Original
bleibt frei und löschbar.
|
Beliebige Quelle, mit kind =
check_duplicate
|
plus ruleSet — die numerische
id aus /api/Ruleset/list
(nicht die Zeichenfolge setId)
|
Filter
filters ist eine Liste von Blöcken,
jeder Block eine Liste von Zeilen
{"field","operator","value"}. Jede Zeile nach
der ersten in einem Block benötigt außerdem "relation"
(AND oder OR). [[]]
bedeutet “kein Filter”.
{
"filters": [[
{ "field":
"Country",
"operator":
"equals", "value":
"FR" },
{ "relation":
"AND", "field":
"Email",
"operator":
"is empty",
"value": ""
}
]]
}
Ablauf der Validierung
Der Server prüft zuerst die JSON-Typen, dann die erforderlichen
Schlüssel, schlägt dann das Credential, das Objekt und die
Datei in der Live-Quelle nach und validiert anschließend
fields und filters. Da die Typen
zuerst geprüft werden, wird ein fehlender
erforderlicher Schlüssel als Key name must be a String.
gemeldet; die Meldung ... need to be set erscheint
nur, wenn der Schlüssel vorhanden, aber leer ist. Standardwerte
bei fehlendem Schlüssel: boolesche Werte false,
mergeThreshold 100. autoMerge: true
aktiviert alle drei automatischen Zusammenführungen auf einmal.
Antwort
Erstellt. HTTP-Status 201.
| Schlüssel | Beschreibung | Typ |
|---|---|---|
| status |
Werte:
success
|
String |
| id | Integer |
Antwortbeispiel
Beispielantwort
{
"status":
"success",
"id": 42
}
Fehler
| HTTP | Body / Bedeutung |
|---|---|
| 400 |
Key name must be a String.
|
| 401 |
Unauthorized
|
| 404 |
Credential not found.
|
| 500 |
Selected Credential seem to be Expired.
|
Bekannte Einschränkungen
-
Processes vom Typ
find_and_replaceundformatscheitern mit einem 500, wenn sie über die API erstellt werden;auditwird akzeptiert, wurde aber nicht verifiziert. Erstellen Sie diese in der Weboberfläche. - Snowflake-Processes scheitern über die API immer an der Validierung (und ein Snowflake-Credential erfordert außerdem eine Anmeldung im Browser).
-
maxRecordsundbackupwerden akzeptiert, haben aber keine Wirkung.
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. Das Erstellen eines Process validiert
gegen Ihre echte Datenquelle.
Konsole öffnen
Process aktualisieren - DQE One Standalone API
Ändert einen bestehenden Process. Dabei wird die vollständige Validierung des Erstellens erneut durchlaufen.
updateProcess
Anfrage
Senden Sie ein PUT mit demselben JSON-Body wie
beim Erstellen sowie der id des Process.
kind, source, object,
die SFTP-Pfade und file können nicht geändert
werden.
Lesen Sie dies vor dem Aktualisieren: (1)
Ein leerer Wert oder
false fällt auf den
aktuellen Wert zurück, sodass ein boolescher Wert
wie sync oder autoMerge
nicht wieder auf false gesetzt und eine
Liste nicht geleert werden kann; (2) der Process wird aus
den von Ihnen gesendeten Werten neu aufgebaut, sodass Felder,
die Sie nicht angeben — einschließlich der Verknüpfung zum
letzten Run — auf ihre Standardwerte zurückfallen, wodurch
auch der Schutz “Process already running” aufgehoben wird;
(3) bei Erfolg lautet der Status HTTP 201,
nicht 200.
PUThttps://{DOMAIN}/api/Process/update
Codebeispiele
Process aktualisieren
curl -u "{EMAIL}:{API_TOKEN}" -X PUT \
-H "Content-Type: application/json" \
-d '{
"id": 42,
"name": "Email check (renamed)",
"kind": "check_email",
"source": "csv",
"primaryKey": "Id",
"fields": {
"FieldLabel": "Email"
}
}' \
"https://{DOMAIN}/api/Process/update"
fetch("https://{DOMAIN}/api/Process/update", {
method: "PUT",
headers: {
"Authorization": "Basic " + btoa("{EMAIL}:{API_TOKEN}"),
"Content-Type": "application/json"
},
body: JSON.stringify({
"id": 42,
"name": "Email check (renamed)",
"kind": "check_email",
"source": "csv",
"primaryKey": "Id",
"fields": {
"FieldLabel": "Email"
}
})
})
.then(r => r.text())
.then(data => console.log(data));
import requests
response = requests.put(
"https://{DOMAIN}/api/Process/update",
auth=("{EMAIL}", "{API_TOKEN}"),
json={"id": 42, "name": "Email check (renamed)",
"kind": "check_email", "source": "csv", "primaryKey":
"Id", "fields": {"FieldLabel": "Email"}},
)
print(response.status_code, response.text)
<?php
$ch = curl_init("https://{DOMAIN}/api/Process/update");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_USERPWD, "{EMAIL}:{API_TOKEN}");
$data = ['id' => 42, 'name' => 'Email check
(renamed)', 'kind' => 'check_email', 'source'
=> 'csv', 'primaryKey' => 'Id', 'fields' =>
['FieldLabel' => 'Email']];
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type:
application/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');
axios({
method: "put",
url: "https://{DOMAIN}/api/Process/update",
auth: { username: "{EMAIL}", password: "{API_TOKEN}"
},
data: {
"id": 42,
"name": "Email check (renamed)",
"kind": "check_email",
"source": "csv",
"primaryKey": "Id",
"fields": {
"FieldLabel": "Email"
}
}
})
.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 body = "{\"id\":42,\"name\":\"Email check
(renamed)\",\"kind\":\"check_email\",\"source\":\"csv\",\"primaryKey\":\"Id\",\"fields\":{\"FieldLabel\":\"Email\"}}";
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://{DOMAIN}/api/Process/update"))
.header("Authorization", "Basic " + auth)
.header("Content-Type", "application/json")
.method("PUT", HttpRequest.BodyPublishers.ofString(body))
.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.Put,
"https://{DOMAIN}/api/Process/update");
request.Content = new StringContent("{\"id\":42,\"name\":\"Email
check (renamed)\",\"kind\":\"check_email\",\"source\":\"csv\",\"primaryKey\":\"Id\",\"fields\":{\"FieldLabel\":\"Email\"}}",
Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine((int)response.StatusCode + " "
+ await response.Content.ReadAsStringAsync());
package main
import (
"bytes"
"fmt"
"io"
"net/http"
)
func main() {
body := []byte(`{"id":42,"name":"Email check (renamed)","kind":"check_email","source":"csv","primaryKey":"Id","fields":{"FieldLabel":"Email"}}`)
req, _ := http.NewRequest("PUT", "https://{DOMAIN}/api/Process/update",
bytes.NewBuffer(body))
req.SetBasicAuth("{EMAIL}", "{API_TOKEN}")
req.Header.Set("Content-Type", "application/json")
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. |
|---|---|---|---|
| name | String | Pflicht | |
| kind |
Werte:
find_and_replace, format,
audit, check_address,
check_b2b, check_email,
check_phone, check_name,
check_duplicate
|
String | Pflicht |
| source |
Werte:
salesforce, dynamics,
postgres, snowflake,
bigquery, sftp,
csv
|
String | Pflicht |
| primaryKey | Muss in den Dateiköpfen bzw. im Quellobjekt vorhanden sein. Bei Salesforce und Dynamics muss es der tatsächliche Primärschlüssel des Objekts sein. | String | Pflicht |
| fields | Aufbau hängt von 'kind' ab - siehe den Artikel Processes ('fields' pro kind). | Object | Pflicht |
| description | String | Optional | |
| file | Nur csv: ID aus /api/File/add. Die Datei wird GEKLONT und mit dem Process verknüpft. | Integer | Optional |
| credential | Jede Quelle außer csv. Der Typ muss zu 'source' passen. | Integer | Optional |
| object | Tabelle / sObject / Entität. Erforderlich für salesforce, dynamics, postgres, snowflake, bigquery. | String | Optional |
| ruleSet | Nur check_duplicate: die numerische 'id' aus /api/Ruleset/list (NICHT die Zeichenfolge setId). | Integer | Optional |
| input_file_path | String | Optional | |
| output_dir_path | String | Optional | |
| reject_dir_path | String | Optional | |
| filters | Liste von Blöcken, jeder eine Liste von Zeilen. [[]] bedeutet kein Filter. | Array | Optional |
| sync |
Standardwert:
false
|
Boolean | Optional |
| allowEmpty |
Standardwert:
false
|
Boolean | Optional |
| autoMerge |
Standardwert:
false
|
Boolean | Optional |
| mergeThreshold |
Standardwert:
100
|
Integer | Optional |
| mergeB2BCode |
Zulässige Elemente:
A+, A,
B+, B, C+,
C, D+, D
|
Array | Optional |
| mergeRNVPCode |
Zulässige Elemente:
10, 20,
21, 22, 23,
24, 25, 30,
31, 40, 41,
50, 51, 60,
61, 70, 71,
80, 81, 90
|
Array | Optional |
| updateChildToInactive |
Standardwert:
false
|
Boolean | Optional |
| deleteSFTP |
Standardwert:
false
|
Boolean | Optional |
| metaToReparent | Object | Optional | |
| next | ID eines Process, der nach diesem verkettet werden soll. | Integer | Optional |
| id | Integer | Pflicht |
Authentifizierung: HTTP Basic — Ihre DQE
One E-Mail-Adresse und Ihr API token (My Account > API Token).
Siehe den Artikel Introduction.
Antwort
Aktualisiert (Hinweis: 201, nicht 200). HTTP-Status 201.
| Schlüssel | Beschreibung | Typ |
|---|---|---|
| status |
Werte:
success
|
String |
| id | Integer |
Antwortbeispiel
Beispielantwort
{
"status":
"success",
"id": 42
}
Fehler
| HTTP | Body / Bedeutung |
|---|---|
| 400 |
No id found.
|
| 401 |
Unauthorized
|
| 404 |
Process 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. Die Aktualisierung ändert Ihren
echten Process.
Konsole öffnen
Process ausführen - DQE One Standalone API
Stellt einen Run des Process in die Warteschlange und kehrt sofort zurück. Die Verarbeitung erfolgt asynchron: Verfolgen Sie sie mit dem Runs-Endpoint.
runProcess
Anfrage
Senden Sie eine GET-Anfrage mit der Process-ID.
Was passiert: Ein Run wird mit dem Status
Started angelegt und in die Warteschlange gestellt.
Jobs laufen pro Benutzer nacheinander, sodass
ein zweiter Run auf den ersten wartet. Das RuleSet, das mit
einem Deduplizierungs-Process verknüpft ist, wird gesperrt
(nicht bearbeitbar), sobald ein Run in die Warteschlange
gestellt wird. Es gibt keinen Endpoint zum Abbrechen eines
Runs.
Lesen Sie immer den Body, nicht nur den HTTP-Status.
Einige Fehler — Entwurfs-Process, keine zu verarbeitende
SFTP-Datei, Fehler bei der Warteschlange — kommen als HTTP
200 mit
{"status":"error","message":"..."} zurück.
run_id ist eine Zeichenfolge.
GEThttps://{DOMAIN}/api/Process/run?id={id}
Codebeispiele
Process ausführen
curl -u "{EMAIL}:{API_TOKEN}" \
"https://{DOMAIN}/api/Process/run?id=42"
fetch("https://{DOMAIN}/api/Process/run?id=42", {
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/Process/run",
auth=("{EMAIL}", "{API_TOKEN}"),
params={"id": "42"},
)
print(response.status_code, response.text)
<?php
$ch = curl_init("https://{DOMAIN}/api/Process/run?id=42");
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/Process/run",
auth: { username: "{EMAIL}", password: "{API_TOKEN}"
},
params: { "id": "42" }
})
.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/Process/run?id=42"))
.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/Process/run?id=42");
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/Process/run?id=42",
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. |
|---|---|---|---|
| id | Process-ID. | Integer | Pflicht |
Authentifizierung: HTTP Basic — Ihre DQE
One E-Mail-Adresse und Ihr API token (My Account > API Token).
Siehe den Artikel Introduction.
Antwort
In die Warteschlange gestellt (oder weicher Fehler). HTTP-Status 200.
| Schlüssel | Beschreibung | Typ |
|---|---|---|
| status |
HTTP 200 wird auch dann zurückgegeben, wenn der
Status 'error' lautet (Process im Entwurfsstatus,
keine SFTP-Datei, Fehler in der Warteschlange).
Werte:
success, error
|
String |
| message | String | |
| run_id | Run-ID als Zeichenfolge. | String |
Antwortbeispiel
Beispielantwort
{
"status":
"success",
"message":
"Process Enqueue",
"run_id": "101"
}
Fehler
| HTTP | Body / Bedeutung |
|---|---|
| 400 |
Process already running
|
| 401 |
Unauthorized
|
| 404 |
Process not found
|
| 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 wird
ein echter Run auf Ihren Daten gestartet.
Konsole öffnen
Process löschen - DQE One Standalone API
Löscht einen Process. Zulässig, wenn der Process ein Entwurf
ist, nie ausgeführt wurde oder sein letzter Run
Finished oder Failed ist.
deleteProcess
Anfrage
Senden Sie eine GET-Anfrage mit der Process-ID
(ja, GET).
GEThttps://{DOMAIN}/api/Process/delete?id={id}
Codebeispiele
Process löschen
curl -u "{EMAIL}:{API_TOKEN}" \
"https://{DOMAIN}/api/Process/delete?id=42"
fetch("https://{DOMAIN}/api/Process/delete?id=42",
{
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/Process/delete",
auth=("{EMAIL}", "{API_TOKEN}"),
params={"id": "42"},
)
print(response.status_code, response.text)
<?php
$ch = curl_init("https://{DOMAIN}/api/Process/delete?id=42");
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/Process/delete",
auth: { username: "{EMAIL}", password: "{API_TOKEN}"
},
params: { "id": "42" }
})
.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/Process/delete?id=42"))
.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/Process/delete?id=42");
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/Process/delete?id=42",
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. |
|---|---|---|---|
| id | Process-ID. | Integer | Pflicht |
Authentifizierung: HTTP Basic — Ihre DQE
One E-Mail-Adresse und Ihr API token (My Account > API Token).
Siehe den Artikel Introduction.
Antwort
Gelöscht. HTTP-Status 200.
| Schlüssel | Beschreibung | Typ |
|---|---|---|
| status |
Werte:
success
|
String |
Antwortbeispiel
Beispielantwort
{
"status":
"success"
}
Fehler
| HTTP | Body / Bedeutung |
|---|---|
| 400 |
No id found.
|
| 401 |
Unauthorized
|
| 404 |
Process not found
|
| 423 |
Process is not in a state that allows deletion
|
| 500 |
Failed to delete the Process
|
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 wird der Process
endgültig gelöscht.
Konsole öffnen
Siehe auch
- DQE One Standalone API — Introduction (Authentifizierung, Konventionen, durchgängiger Ablauf)
- DQE One Standalone API — Files, Credentials, Runs & results, RuleSets
- Use the Lookup API in DQE One Standalone
- Field Reference in DQE One Standalone
Verknüpfung mit