Dictanova API

aggregation

Search documents aggregate

posthttps://api.dictanova.io/v1/aggregation/datasets/datasetId/documents

curl --request POST \
  --url https://api.dictanova.io/v1/aggregation/datasets/datasetId/documents \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/aggregation/datasets/datasetId/documents',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/aggregation/datasets/datasetId/documents")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/aggregation/datasets/datasetId/documents");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/aggregation/datasets/datasetId/documents"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Query Params

string

Body Params

field

string

Field concerned by the aggregation, document metadata are prefixed by 'metadata.'

type

string

Type of aggregation

periods

array of objects

Period buckets of the aggregation

field

from

dimensions

array of objects

Dimension buckets of the aggregation

field

group

limit

ranges

query

object

Query applied to the aggregation

query.operator

string

Headers

Authorization

string

required

JWT Token

Response

Search OK

field	string Field concerned by the aggregation, document metadata are prefixed by 'metadata.'
type	string Type of aggregation
periods	array Period buckets of the aggregation

classifiers

List of supported classifiers

gethttps://api.dictanova.io/v1/management/classifiers

curl --request GET \
  --url https://api.dictanova.io/v1/management/classifiers \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/classifiers',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/classifiers")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/classifiers");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/classifiers"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

datasets

Get a dataset by its id

gethttps://api.dictanova.io/v1/management/datasets/datasetId

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets/datasetId \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets/datasetId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Headers

Authorization

string

required

JWT Token

Response

name	string Dataset name
lang	string Dataset lang
type	string Dataset type
industry	string Dataset industry
daysOfRetention	integer Data retention period in days (override default from organisation)
metadataDefinitions	array Dataset metadata
classifiers	array Names of the classifiers to apply to this dataset
id	string Dataset id
createdAt	string Dataset creation date
updatedAt	string Dataset last update date
documentsCount	integer Current number of documents

List of all datasets

gethttps://api.dictanova.io/v1/management/datasets

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Query Params

page

int32

pageSize

int32

Headers

Authorization

string

required

JWT Token

Response

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

Create a dataset

posthttps://api.dictanova.io/v1/management/datasets

curl --request POST \
  --url https://api.dictanova.io/v1/management/datasets \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/management/datasets',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/management/datasets");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Body Params

name

string

Dataset name

lang

string

required

Dataset lang

type

string

required

Dataset type

industry

string

Dataset industry

daysOfRetention

int32

Data retention period in days (override default from organisation)

metadataDefinitions

array of objects

Dataset metadata

code

type

bounds

mandatory

personalData

maxLength

allowedValues

classifiers

array of strings

Names of the classifiers to apply to this dataset

Headers

Authorization

string

required

JWT Token

Response

Dataset successfully created

name	string Dataset name
lang	string Dataset lang
type	string Dataset type
industry	string Dataset industry
daysOfRetention	integer Data retention period in days (override default from organisation)
metadataDefinitions	array Dataset metadata
classifiers	array Names of the classifiers to apply to this dataset
id	string Dataset id
createdAt	string Dataset creation date
updatedAt	string Dataset last update date
documentsCount	integer Current number of documents

Archive a dataset

puthttps://api.dictanova.io/v1/management/datasets/datasetId/archive

curl --request PUT \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/archive \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'PUT',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/archive',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/archive")

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

request = Net::HTTP::Put.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.dictanova.io/v1/management/datasets/datasetId/archive");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/archive"

headers = {'authorization': 'Authorization'}

response = requests.request("PUT", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Headers

Authorization

string

required

JWT Token

Response

Dataset successfully archived

Launch analyze on a dataset

posthttps://api.dictanova.io/v1/management/datasets/datasetId/analyze

curl --request POST \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/analyze \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/analyze',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/analyze")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/management/datasets/datasetId/analyze");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/analyze"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Headers

Authorization

string

required

JWT Token

Response

Dataset analyze launched (async handling)

Launch topic generation on a dataset, existing topics will be deleted by this action

posthttps://api.dictanova.io/v1/management/datasets/datasetId/activate-topics

curl --request POST \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/activate-topics \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/activate-topics',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/activate-topics")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/management/datasets/datasetId/activate-topics");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/activate-topics"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Body Params

numberOfTopics

int32

Number of topics to generate

mainTermsIds

array of strings

Terms to use as main terms for topics generation

Headers

Authorization

string

required

JWT Token

Response

Topic generation launched (async handling)

Activate the specified classifiers, then launch analysis of a dataset, existing tags will be deleted by this action.

posthttps://api.dictanova.io/v1/management/datasets/datasetId/activate-classifiers

curl --request POST \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/activate-classifiers \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/activate-classifiers',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/activate-classifiers")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/management/datasets/datasetId/activate-classifiers");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/activate-classifiers"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Body Params

classifiers

array of strings

Names of the classifiers to apply to this dataset

Headers

Authorization

string

required

JWT Token

Response

Classification launched (async handling)

documents

Get a document by its external id

gethttps://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

externalId

string

required

Headers

Authorization

string

required

JWT Token

Response

externalId	string Document id provided by client
lang	string Document lang
type	string Document data type
content	string Document text content
metadata	array Document metadata
id	string Document id
createdAt	string Document creation date
updatedAt	string Document last update date
state	string Document state
enrichments	array Document enrichments
lastOpinionEnrichment	string Document last opinion enrichment date
classifications	array Document classifications
lastDocumentClassification	string Document last classification date

Delete a document by external id

deletehttps://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId

curl --request DELETE \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'DELETE',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/documents/externalId"

headers = {'authorization': 'Authorization'}

response = requests.request("DELETE", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

externalId

string

required

Headers

Authorization

string

required

JWT Token

Response

Document successfully deleted

imports

List of all imports in dataset

gethttps://api.dictanova.io/v1/management/datasets/datasetId/imports

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/imports \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/imports',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/imports")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets/datasetId/imports");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/imports"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Query Params

page

int32

pageSize

int32

Headers

Authorization

string

required

JWT Token

Response

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

Create a new import from CSV

posthttps://api.dictanova.io/v1/management/datasets/datasetId/imports

curl --request POST \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/imports \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/imports',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/imports")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/management/datasets/datasetId/imports");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/imports"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Headers

Authorization

string

required

JWT Token

Response

Import launched (async handling)

id	string Import id
createdAt	string Import creation date
updatedAt	string Import last update date
endedAt	string Import end date
state	string Import state
totalDocuments	integer Total documents
processedDocuments	integer Processed documents
totalErrors	integer Total of import errors
errors	array Import errors

Get an import by its id

gethttps://api.dictanova.io/v1/management/datasets/datasetId/imports/importId

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

importId

string

required

Headers

Authorization

string

required

JWT Token

Response

id	string Import id
createdAt	string Import creation date
updatedAt	string Import last update date
endedAt	string Import end date
state	string Import state
totalDocuments	integer Total documents
processedDocuments	integer Processed documents
totalErrors	integer Total of import errors
errors	array Import errors

List of all documents of an import

gethttps://api.dictanova.io/v1/management/datasets/datasetId/imports/importId/documents

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId/documents \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId/documents',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId/documents")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId/documents");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/imports/importId/documents"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

importId

string

required

Query Params

page

int32

pageSize

int32

Headers

Authorization

string

required

JWT Token

Response

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

info

Get active subscription

gethttps://api.dictanova.io/v1/info/subscription

curl --request GET \
  --url https://api.dictanova.io/v1/info/subscription \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/info/subscription',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/info/subscription")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/info/subscription");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/info/subscription"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

package	object
package.code	string
package.name	string
package.documentQuota	integer
package.daysOfRetention	integer
package.maxDataset	integer
package.maxMetadataPerDataset	integer
package.blocked	boolean
startDate	string
endDate	string

Get subscriptions history

gethttps://api.dictanova.io/v1/info/subscription/history

curl --request GET \
  --url https://api.dictanova.io/v1/info/subscription/history \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/info/subscription/history',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/info/subscription/history")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/info/subscription/history");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/info/subscription/history"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

Get current consumption

gethttps://api.dictanova.io/v1/info/consumption

curl --request GET \
  --url https://api.dictanova.io/v1/info/consumption \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/info/consumption',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/info/consumption")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/info/consumption");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/info/consumption"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

startDate	string
endDate	string
debited	integer
credited	integer

Get consumptions history

gethttps://api.dictanova.io/v1/info/consumption/history

curl --request GET \
  --url https://api.dictanova.io/v1/info/consumption/history \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/info/consumption/history',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/info/consumption/history")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/info/consumption/history");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/info/consumption/history"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

Get client information

gethttps://api.dictanova.io/v1/info

curl --request GET \
  --url https://api.dictanova.io/v1/info \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/info',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/info")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/info");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/info"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

clientId	string Client Identifier
organization	object Client organization info
organization.id	string Organization id
organization.name	string Organization name
organization.createdAt	string Organization creation date
organization.updatedAt	string Organization last update date
organization.state	string Organization state
organization.webhooks	array List of webhooks for organization

search

Search terms

posthttps://api.dictanova.io/v1/search/datasets/datasetId/terms

curl --request POST \
  --url https://api.dictanova.io/v1/search/datasets/datasetId/terms \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/search/datasets/datasetId/terms',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/search/datasets/datasetId/terms")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/search/datasets/datasetId/terms");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/search/datasets/datasetId/terms"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Query Params

page

int32

pageSize

int32

sortOrder

string

opinions

array of strings

Body Params

operator

string

Headers

Authorization

string

required

JWT Token

Response

Search OK

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

Search documents

posthttps://api.dictanova.io/v1/search/datasets/datasetId/documents

curl --request POST \
  --url https://api.dictanova.io/v1/search/datasets/datasetId/documents \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/search/datasets/datasetId/documents',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/search/datasets/datasetId/documents")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/search/datasets/datasetId/documents");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/search/datasets/datasetId/documents"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Query Params

string

page

int32

pageSize

int32

sortBy

string

sortOrder

string

Body Params

operator

string

Headers

Authorization

string

required

JWT Token

Response

Search OK

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

token

Generate a new access_token

posthttps://api.dictanova.io/v1/token

curl --request POST \
  --url https://api.dictanova.io/v1/token

var request = require("request");

var options = { method: 'POST', url: 'https://api.dictanova.io/v1/token' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/token")

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

request = Net::HTTP::Post.new(url)

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/token");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/token"

response = requests.request("POST", url)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Body Params

clientId

string

clientSecret

string

Response

access_token	string
token_type	string
expires_in	integer

success	boolean This is an error
errors	array

topics

List active topics of the given dataset

gethttps://api.dictanova.io/v1/management/datasets/datasetId/topics

curl --request GET \
  --url https://api.dictanova.io/v1/management/datasets/datasetId/topics \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/datasets/datasetId/topics',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/datasets/datasetId/topics")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/datasets/datasetId/topics");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/datasets/datasetId/topics"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

datasetId

string

required

Query Params

page

int32

pageSize

int32

Headers

Authorization

string

required

JWT Token

Response

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

webhooks

List of all configured webhooks

gethttps://api.dictanova.io/v1/management/webhooks

curl --request GET \
  --url https://api.dictanova.io/v1/management/webhooks \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/webhooks',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/webhooks")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/webhooks");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/webhooks"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Headers

Authorization

string

required

JWT Token

Response

Add a new webhook to organization

posthttps://api.dictanova.io/v1/management/webhooks

curl --request POST \
  --url https://api.dictanova.io/v1/management/webhooks \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'POST',
  url: 'https://api.dictanova.io/v1/management/webhooks',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/webhooks")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://api.dictanova.io/v1/management/webhooks");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/webhooks"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Body Params

url

string

required

Webhook url

event

string

required

Webhook event

Headers

Authorization

string

required

JWT Token

Response

Webhook added

Update an existing webhook endpoint

puthttps://api.dictanova.io/v1/management/webhooks/webhookEvent

curl --request PUT \
  --url https://api.dictanova.io/v1/management/webhooks/webhookEvent \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'PUT',
  url: 'https://api.dictanova.io/v1/management/webhooks/webhookEvent',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/webhooks/webhookEvent")

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

request = Net::HTTP::Put.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "https://api.dictanova.io/v1/management/webhooks/webhookEvent");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/webhooks/webhookEvent"

headers = {'authorization': 'Authorization'}

response = requests.request("PUT", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

webhookEvent

string

required

Body Params

url

string

required

Webhook url

Headers

Authorization

string

required

JWT Token

Response

Webhook updated

Delete an existing webhook

deletehttps://api.dictanova.io/v1/management/webhooks/webhookEvent

curl --request DELETE \
  --url https://api.dictanova.io/v1/management/webhooks/webhookEvent \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'DELETE',
  url: 'https://api.dictanova.io/v1/management/webhooks/webhookEvent',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/webhooks/webhookEvent")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "https://api.dictanova.io/v1/management/webhooks/webhookEvent");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/webhooks/webhookEvent"

headers = {'authorization': 'Authorization'}

response = requests.request("DELETE", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

webhookEvent

string

required

Headers

Authorization

string

required

JWT Token

Response

Webhook deleted

Gets history of webhook event call results

gethttps://api.dictanova.io/v1/management/webhooks/webhookEvent/responses

curl --request GET \
  --url https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

webhookEvent

string

required

Query Params

page

int32

pageSize

int32

Headers

Authorization

string

required

JWT Token

Response

page	integer Current page (start with 1 index)
pageSize	integer Current page size (default to 20 items)
total	integer Total number of items
items	array Items for current page

Gets history of webhook event call results

gethttps://api.dictanova.io/v1/management/webhooks/webhookEvent/responses/responseId

curl --request GET \
  --url https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses/responseId \
  --header 'authorization: Authorization'

var request = require("request");

var options = {
  method: 'GET',
  url: 'https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses/responseId',
  headers: { authorization: 'Authorization' }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

require 'uri'
require 'net/http'

url = URI("https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses/responseId")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

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

var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses/responseId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);

import requests

url = "https://api.dictanova.io/v1/management/webhooks/webhookEvent/responses/responseId"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)

{{ results.statusCode[0] }} {{ results.statusCode[1] }}

Metadata

A binary file was returned

You couldn't be authenticated

Method

URL

Request Headers

{{ results.requestHeaders }}

Request Data

{{ results.data }}

Status

Response Headers

{{ results.responseHeaders }}

Try the API to see results

Path Params

webhookEvent

string

required

responseId

string

required

Headers

Authorization

string

required

JWT Token

Response

id	string Webhook response id
event	string Webhook event
triggeredAt	string The time this event was triggered
statusCode	integer Status code of the request, -1 means target url couldn't be reached.
request	object Request data
request.headers	string Headers
request.content	string Content
reply	object Reply data
reply.headers	string Headers
reply.content	string Content
reply.statusCode	integer Reply status code

Path Params

Query Params

Body Params

Headers

200Response

Headers

200404Response

Path Params

Headers

200Response

Query Params

Headers

200Response

Body Params

Headers

201400Response

Path Params

Headers

204400Response

Path Params

Headers

202400Response

Path Params

Body Params

Headers

202Response

Path Params

Body Params

Headers

202Response

Path Params

Headers

200404Response

Path Params

Headers

204404Response

Path Params

Query Params

Headers

200Response

Path Params

Headers

202Response

Path Params

Headers

200404Response

Path Params

Query Params

Headers

200204404Response

Headers

200404Response

Headers

200404Response

Headers

200404Response

Headers

200404Response

Headers

200404Response

Path Params

Query Params

Body Params

Headers

200Response

Path Params

Query Params

Body Params

Headers

200Response

Body Params

200400Response

Path Params

Query Params

Headers

200204Response

Headers

200404Response

Body Params

Headers

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response