Processes

Processes - DQE One Standalone API

Créez, mettez à jour, lancez et supprimez des processes de qualité de données sur votre serveur DQE One Standalone auto-hébergé. Un process associe une source de données (un fichier CSV, une base de données ou un CRM) à une action telle que la vérification d'emails, de téléphones, d'adresses, de noms ou d'entreprises, ou la recherche de doublons.

{DOMAIN} est le nom d'hôte de votre propre serveur DQE One Standalone — il est auto-hébergé, cette valeur dépend donc de votre déploiement. {EMAIL} est votre identifiant de connexion DQE One et {API_TOKEN} le token généré dans My Account > API Token.

Ordre habituel : téléversez un fichier (Files) ou créez un credential (Credentials) → createProcess → runProcess → interrogez le run (Runs) → téléchargez le résultat.
Documentation associée : DQE One Standalone API — Introduction, Files, Credentials, Runs & results, RuleSets.

Deux opérations modifient des données via un GET : runProcess et deleteProcess sont des requêtes GET alors qu'elles démarrent un run et suppriment un process. Ne placez jamais ces URL dans un crawler, un outil de préchargement de liens ou tout ce qui rejoue des requêtes GET.

Aller àlistProcesses getProcess createProcess updateProcess runProcess deleteProcess

Lister les processes - DQE One Standalone API

Liste les processes que vous possédez, sans ordre particulier.

listProcesses

Aller à Paramètres Réponse Exemple Erreurs ▶ Tester l'API

Requête

Envoyez une requête GET avec vos credentials Basic. Il n'y a aucun paramètre.

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

Exemples de code

Lister vos processes

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                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))
                }
              

Paramètres

Cet endpoint ne prend aucun paramètre.

Authentification : HTTP Basic — votre email DQE One et votre API token (My Account > API Token). Consultez l'article Introduction.

Réponse

Tableau. Statut HTTP 200.

Le corps est un tableau JSON ; chaque élément contient ces clés.

Clé	Description	Type
id		Integer
name		String
type		String
isDraft		Boolean
lastRunId		Integer

Exemple de réponse

              [
              {
              "id": 42,
              "name":
              "Email check",
              "type":
              "check_email",
              "isDraft": false,
              "lastRunId": 101
              }
              ]
            

Erreurs

HTTP	Corps / signification
401	`Unauthorized`
500	`Unexpected error`

Tester l'API

Cliquez sur le bouton ci-dessous pour tester cet endpoint en direct dans votre navigateur.

À savoir : cette console envoie une vraie requête à votre propre serveur depuis votre navigateur, avec votre véritable API token.

Ouvrir la console

Console API GET /api/Process/list

Domaine du serveur

Authentification (HTTP Basic)

Email requis

API token requis

Paramètres

Aucun paramètre.

cURLJSPythonPHPNodeJavaC#Go

Obtenir un process - DQE One Standalone API

Renvoie les détails d'un process. Un process appartenant à un autre utilisateur renvoie 404.

getProcess

Aller à Paramètres Réponse Exemple Erreurs ▶ Tester l'API

Requête

Envoyez une requête GET avec l'id du process.

Problème connu : pour un process sans fichier lié (toute source autre que CSV), cet endpoint peut répondre par une erreur HTTP 500 non formatée au lieu d'un JSON.

GEThttps://{DOMAIN}/api/Process/get?id={id}

Exemples de code

Obtenir un process

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                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))
                }
              

Paramètres

Champ	Description	Type	Obl / Opt
id	Id du process.	Integer	Obligatoire

Authentification : HTTP Basic — votre email DQE One et votre API token (My Account > API Token). Consultez l'article Introduction.

Réponse

Process. Statut HTTP 200.

Clé	Description	Type
id		Integer
name		String
type	Kind du process.	String
source		String
description		String
file		Integer
credentials		Integer
ruleSet		Integer
lastRunId		Integer
createdBy		String
updatedBy		String
createdOn		String
updatedOn		String

Exemple de réponse

La réponse est une pièce jointe, pas du JSON.

Erreurs

HTTP	Corps / signification
400	`No id found.`
401	`Unauthorized`
404	`Process not found`

Tester l'API

Cliquez sur le bouton ci-dessous pour tester cet endpoint en direct dans votre navigateur.

À savoir : cette console envoie une vraie requête à votre propre serveur depuis votre navigateur, avec votre véritable API token.

Ouvrir la console

Console API GET /api/Process/get

Domaine du serveur

Authentification (HTTP Basic)

Email requis

API token requis

Paramètres

id requis

cURLJSPythonPHPNodeJavaC#Go

Créer un process - DQE One Standalone API

Crée un process immédiatement prêt à être lancé (il n'est pas enregistré comme brouillon). La validation est stricte et vérifie la source en direct : un credential, un objet ou un champ incorrect est donc signalé dès la création.

createProcess

Aller à Paramètres Réponse Exemple Erreurs ▶ Tester l'API

Requête

Envoyez un corps JSON. Obligatoires : name, kind, source, primaryKey et fields ; le reste dépend de la source et du kind (tableaux ci-dessous).

POSThttps://{DOMAIN}/api/Process/create

Exemples de code

Créer un process

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                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))
                }
              

Paramètres

Champ	Description	Type	Obl / Opt
name		String	Obligatoire
kind	Valeurs : `find_and_replace`, `format`, `audit`, `check_address`, `check_b2b`, `check_email`, `check_phone`, `check_name`, `check_duplicate`	String	Obligatoire
source	Valeurs : `salesforce`, `dynamics`, `postgres`, `snowflake`, `bigquery`, `sftp`, `csv`	String	Obligatoire
primaryKey	Doit exister dans les en-têtes du fichier / l'objet source. Pour Salesforce et Dynamics, ce doit être la véritable clé primaire de l'objet.	String	Obligatoire
fields	La forme dépend de 'kind' - voir l'article Processes ('fields' par kind).	Object	Obligatoire
description		String	Optionnel
file	csv uniquement : id renvoyé par /api/File/add. Le fichier est CLONÉ et lié au process.	Integer	Optionnel
credential	Toutes les sources sauf csv. Son type doit correspondre à 'source'.	Integer	Optionnel
object	Table / sObject / entité. Obligatoire pour salesforce, dynamics, postgres, snowflake, bigquery.	String	Optionnel
ruleSet	check_duplicate uniquement : l'id numérique 'id' de /api/Ruleset/list (PAS le setId de type chaîne).	Integer	Optionnel
input_file_path		String	Optionnel
output_dir_path		String	Optionnel
reject_dir_path		String	Optionnel
filters	Liste de blocs, chacun étant une liste de lignes. [[]] signifie aucun filtre.	Array	Optionnel
sync	Par défaut : `false`	Boolean	Optionnel
allowEmpty	Par défaut : `false`	Boolean	Optionnel
autoMerge	Par défaut : `false`	Boolean	Optionnel
mergeThreshold	Par défaut : `100`	Integer	Optionnel
mergeB2BCode	Éléments autorisés : `A+`, `A`, `B+`, `B`, `C+`, `C`, `D+`, `D`	Array	Optionnel
mergeRNVPCode	Éléments autorisés : `10`, `20`, `21`, `22`, `23`, `24`, `25`, `30`, `31`, `40`, `41`, `50`, `51`, `60`, `61`, `70`, `71`, `80`, `81`, `90`	Array	Optionnel
updateChildToInactive	Par défaut : `false`	Boolean	Optionnel
deleteSFTP	Par défaut : `false`	Boolean	Optionnel
metaToReparent		Object	Optionnel
next	Id d'un process à enchaîner après celui-ci.	Integer	Optionnel

Authentification : HTTP Basic — votre email DQE One et votre API token (My Account > API Token). Consultez l'article Introduction.

L'objet `fields`, par `kind`

Chaque valeur est le nom d'une colonne (CSV) ou d'un champ (base de données/CRM) qui doit exister dans la source ; primaryKey également.

kind	Clés dans `fields`
check_email	`FieldLabel`
check_phone	`CountryField`, `FieldLabel`, `Format`
check_name	`Salutation`, `FirstName`, `LastName`
check_address	`City`, `Country`, `DefaultCountry`, `FieldTag`, `PostalCode`, `Street` ; `State` optionnel
check_b2b	`City`, `CompanyName`, `Country`, `PostalCode`, `Siret`, `Street` ; `State` optionnel, plus les clés `DQE_<field>` pour les champs supplémentaires de la notice B2B
check_duplicate	Une clé = la chaîne `setId` du RuleSet ; sa valeur est la liste des libellés de règles de correspondance à utiliser, qui doivent figurer parmi les `matching.Labels[].value` du RuleSet (lisez-les avec `/api/Ruleset/get`). Exemple : `{"RS_ABC": ["Email + Name"]}`
find_and_replace, format, audit	Non utilisable via l'API actuellement — voir Limitations connues ci-dessous.

Clés requises, par `source`

source	Clés requises en plus de name, kind, source, primaryKey, fields
salesforce, dynamics, postgres, bigquery	`object`, `credential` (son type doit correspondre à la source)
snowflake	Idem, mais les processes Snowflake échouent actuellement à la validation (voir les limitations)
sftp	`credential`, `input_file_path`, `output_dir_path`, `reject_dir_path` (les trois chemins doivent exister sur le serveur SFTP)
csv	`file` — l'id renvoyé par `/api/File/add`. Le fichier est cloné et le clone est lié au process ; l'original reste libre et supprimable.
Toute source, avec `kind` = `check_duplicate`	plus `ruleSet` — l'identifiant numérique `id` de `/api/Ruleset/list` (pas la chaîne `setId`)

Filtres

filters est une liste de blocs, chaque bloc étant une liste de lignes {"field","operator","value"}. Chaque ligne après la première d'un bloc nécessite aussi "relation" (AND ou OR). [[]] signifie “aucun filtre”.

            {
            "filters": [[
            { "field":
            "Country",
            "operator":
            "equals", "value":
            "FR" },
            { "relation":
            "AND", "field":
            "Email",
            "operator":
            "is empty",
            "value": ""
            }
            ]]
            }
          

Déroulement de la validation

Le serveur vérifie d'abord les types JSON, puis les clés requises, puis recherche le credential, l'objet et le fichier sur la source en direct, et enfin valide fields et filters. Les types étant vérifiés en premier, une clé requise manquante est signalée par Key name must be a String. ; le message ... need to be set n'apparaît que lorsque la clé est présente mais vide. Valeurs par défaut lorsqu'une clé est absente : booléens false, mergeThreshold 100. autoMerge: true active les trois fusions automatiques à la fois.

Réponse

Créé. Statut HTTP 201.

Clé	Description	Type
status	Valeurs : `success`	String
id		Integer

Exemple de réponse

              {
              "status":
              "success",
              "id": 42
              }
            

Erreurs

HTTP	Corps / signification
400	`Key name must be a String.`
401	`Unauthorized`
404	`Credential not found.`
500	`Selected Credential seem to be Expired.`

Limitations connues

Les processes find_and_replace et format échouent avec une erreur 500 lorsqu'ils sont créés via l'API ; audit est accepté mais n'a pas été vérifié. Créez-les dans l'interface web.
Les processes Snowflake échouent toujours à la validation via l'API (et un credential Snowflake nécessite aussi une connexion via navigateur).
maxRecords et backup sont acceptés mais sans effet.

Tester l'API

Cliquez sur le bouton ci-dessous pour tester cet endpoint en direct dans votre navigateur.

À savoir : cette console envoie une vraie requête à votre propre serveur depuis votre navigateur, avec votre véritable API token. La création d'un process est validée par rapport à votre véritable source de données.

Ouvrir la console

Console API POST /api/Process/create

Domaine du serveur

Authentification (HTTP Basic)

Email requis

API token requis

Paramètres

Corps de la requête (JSON) requis

cURLJSPythonPHPNodeJavaC#Go

Mettre à jour un process - DQE One Standalone API

Modifie un process existant. Il rejoue l'intégralité de la validation de création.

updateProcess

Aller à Paramètres Réponse Exemple Erreurs ▶ Tester l'API

Requête

Envoyez un PUT avec le même corps JSON que pour la création, plus l'id du process. kind, source, object, les chemins SFTP et file ne peuvent pas être modifiés.

À lire avant de mettre à jour : (1) une valeur vide ou false revient à la valeur actuelle : un booléen tel que sync ou autoMerge ne peut donc pas être remis à false et une liste ne peut pas être vidée ; (2) le process est reconstruit à partir des valeurs que vous envoyez : les champs que vous ne listez pas — y compris son lien vers le dernier run — reprennent leurs valeurs par défaut, ce qui lève aussi la protection “Process already running” ; (3) le succès est un HTTP 201, et non 200.

PUThttps://{DOMAIN}/api/Process/update

Exemples de code

Mettre à jour un process

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                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))
                }
              

Paramètres

Champ	Description	Type	Obl / Opt
name		String	Obligatoire
kind	Valeurs : `find_and_replace`, `format`, `audit`, `check_address`, `check_b2b`, `check_email`, `check_phone`, `check_name`, `check_duplicate`	String	Obligatoire
source	Valeurs : `salesforce`, `dynamics`, `postgres`, `snowflake`, `bigquery`, `sftp`, `csv`	String	Obligatoire
primaryKey	Doit exister dans les en-têtes du fichier / l'objet source. Pour Salesforce et Dynamics, ce doit être la véritable clé primaire de l'objet.	String	Obligatoire
fields	La forme dépend de 'kind' - voir l'article Processes ('fields' par kind).	Object	Obligatoire
description		String	Optionnel
file	csv uniquement : id renvoyé par /api/File/add. Le fichier est CLONÉ et lié au process.	Integer	Optionnel
credential	Toutes les sources sauf csv. Son type doit correspondre à 'source'.	Integer	Optionnel
object	Table / sObject / entité. Obligatoire pour salesforce, dynamics, postgres, snowflake, bigquery.	String	Optionnel
ruleSet	check_duplicate uniquement : l'id numérique 'id' de /api/Ruleset/list (PAS le setId de type chaîne).	Integer	Optionnel
input_file_path		String	Optionnel
output_dir_path		String	Optionnel
reject_dir_path		String	Optionnel
filters	Liste de blocs, chacun étant une liste de lignes. [[]] signifie aucun filtre.	Array	Optionnel
sync	Par défaut : `false`	Boolean	Optionnel
allowEmpty	Par défaut : `false`	Boolean	Optionnel
autoMerge	Par défaut : `false`	Boolean	Optionnel
mergeThreshold	Par défaut : `100`	Integer	Optionnel
mergeB2BCode	Éléments autorisés : `A+`, `A`, `B+`, `B`, `C+`, `C`, `D+`, `D`	Array	Optionnel
mergeRNVPCode	Éléments autorisés : `10`, `20`, `21`, `22`, `23`, `24`, `25`, `30`, `31`, `40`, `41`, `50`, `51`, `60`, `61`, `70`, `71`, `80`, `81`, `90`	Array	Optionnel
updateChildToInactive	Par défaut : `false`	Boolean	Optionnel
deleteSFTP	Par défaut : `false`	Boolean	Optionnel
metaToReparent		Object	Optionnel
next	Id d'un process à enchaîner après celui-ci.	Integer	Optionnel
id		Integer	Obligatoire

Authentification : HTTP Basic — votre email DQE One et votre API token (My Account > API Token). Consultez l'article Introduction.

Réponse

Mis à jour (à noter : 201, et non 200). Statut HTTP 201.

Clé	Description	Type
status	Valeurs : `success`	String
id		Integer

Exemple de réponse

              {
              "status":
              "success",
              "id": 42
              }
            

Erreurs

HTTP	Corps / signification
400	`No id found.`
401	`Unauthorized`
404	`Process not found.`

Tester l'API

Cliquez sur le bouton ci-dessous pour tester cet endpoint en direct dans votre navigateur.

À savoir : cette console envoie une vraie requête à votre propre serveur depuis votre navigateur, avec votre véritable API token. La mise à jour modifie votre véritable process.

Ouvrir la console

Console API PUT /api/Process/update

Domaine du serveur

Authentification (HTTP Basic)

Email requis

API token requis

Paramètres

Corps de la requête (JSON) requis

cURLJSPythonPHPNodeJavaC#Go

Lancer un process - DQE One Standalone API

Met un run du process en file d'attente et répond immédiatement. Le traitement est asynchrone : suivez-le avec l'endpoint Runs.

runProcess

Aller à Paramètres Réponse Exemple Erreurs ▶ Tester l'API

Requête

Envoyez une requête GET avec l'id du process.

Ce qui se passe : un run est créé avec le statut Started et mis en file d'attente. Les jobs s'exécutent un par un pour chaque utilisateur : un second run attend donc la fin du premier. Le RuleSet lié à un process de déduplication est verrouillé (non modifiable) dès qu'un run est mis en file d'attente. Il n'existe aucun endpoint pour annuler un run.

Lisez toujours le corps de la réponse, pas seulement le statut HTTP. Certains échecs — process en brouillon, aucun fichier SFTP à traiter, échec de la mise en file d'attente — reviennent avec un HTTP 200 et {"status":"error","message":"..."}. run_id est une chaîne.

GEThttps://{DOMAIN}/api/Process/run?id={id}

Exemples de code

Lancer un process

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                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))
                }
              

Paramètres

Champ	Description	Type	Obl / Opt
id	Id du process.	Integer	Obligatoire

Authentification : HTTP Basic — votre email DQE One et votre API token (My Account > API Token). Consultez l'article Introduction.

Réponse

Mis en file d'attente (ou erreur douce). Statut HTTP 200.

Clé	Description	Type
status	Un HTTP 200 est renvoyé même lorsque le statut est 'error' (process en brouillon, aucun fichier SFTP, échec de la file d'attente). Valeurs : `success`, `error`	String
message		String
run_id	Id du run, sous forme de chaîne.	String

Exemple de réponse

              {
              "status":
              "success",
              "message":
              "Process Enqueue",
              "run_id": "101"
              }
            

Erreurs

HTTP	Corps / signification
400	`Process already running`
401	`Unauthorized`
404	`Process not found`
500

Tester l'API

Cliquez sur le bouton ci-dessous pour tester cet endpoint en direct dans votre navigateur.

À savoir : cette console envoie une vraie requête à votre propre serveur depuis votre navigateur, avec votre véritable API token. Cela démarre un vrai run sur vos données.

Ouvrir la console

Console API GET /api/Process/run

Domaine du serveur

Authentification (HTTP Basic)

Email requis

API token requis

Paramètres

id requis

cURLJSPythonPHPNodeJavaC#Go

Supprimer un process - DQE One Standalone API

Supprime un process. Autorisé lorsque le process est un brouillon, n'a jamais été exécuté, ou que son dernier run est Finished ou Failed.

deleteProcess

Aller à Paramètres Réponse Exemple Erreurs ▶ Tester l'API

Requête

Envoyez une requête GET avec l'id du process (oui, GET).

GEThttps://{DOMAIN}/api/Process/delete?id={id}

Exemples de code

Supprimer un process

cURLJavaScriptPythonPHPNode.jsJavaC#Go

                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))
                }
              

Paramètres

Champ	Description	Type	Obl / Opt
id	Id du process.	Integer	Obligatoire

Authentification : HTTP Basic — votre email DQE One et votre API token (My Account > API Token). Consultez l'article Introduction.

Réponse

Supprimé. Statut HTTP 200.

Clé	Description	Type
status	Valeurs : `success`	String

Exemple de réponse

              {
              "status":
              "success"
              }
            

Erreurs

HTTP	Corps / signification
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`

Tester l'API

Cliquez sur le bouton ci-dessous pour tester cet endpoint en direct dans votre navigateur.

À savoir : cette console envoie une vraie requête à votre propre serveur depuis votre navigateur, avec votre véritable API token. Cela supprime définitivement le process.

Ouvrir la console

Console API GET /api/Process/delete

Domaine du serveur

Authentification (HTTP Basic)

Email requis

API token requis

Paramètres

id requis

cURLJSPythonPHPNodeJavaC#Go

Voir aussi

DQE One Standalone API — Introduction (authentification, conventions, workflow de bout en bout)
DQE One Standalone API — Files, Credentials, Runs & results, RuleSets
Use the Lookup API in DQE One Standalone
Field Reference in DQE One Standalone

listProcesses

Requête

Exemples de code

Paramètres

Réponse

Exemple de réponse

Erreurs

Tester l'API

getProcess

Requête

Exemples de code

Paramètres

Réponse

Exemple de réponse

Erreurs

Tester l'API

createProcess

Requête

Exemples de code

Paramètres

L'objet fields, par kind

Clés requises, par source

Filtres

Déroulement de la validation

Réponse

Exemple de réponse

Erreurs

Limitations connues

Tester l'API

updateProcess

Requête

Exemples de code

Paramètres

Réponse

Exemple de réponse

Erreurs

Tester l'API

runProcess

Requête

Exemples de code

Paramètres

Réponse

Exemple de réponse

Erreurs

Tester l'API

deleteProcess

Requête

Exemples de code

Paramètres

Réponse

Exemple de réponse

Erreurs

Tester l'API

Voir aussi

Cet article vous a-t-il été utile ?

Article précédent

Article suivant

L'objet `fields`, par `kind`

Clés requises, par `source`