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

datasets

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

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
id	string Dataset id
state	string Dataset state
createdAt	string Dataset creation date
updatedAt	string Dataset last update date
monthlyImportedDocuments	array Dataset monthly counter of imported documents

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
id	string Dataset id
state	string Dataset state
createdAt	string Dataset creation date
updatedAt	string Dataset last update date
monthlyImportedDocuments	array Dataset monthly counter of imported documents

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

Analyze successfully launched

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

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

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

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

Body Params

documents

array of objects

The documents to import.

externalId

lang

type

content

metadata

Headers

Authorization

string

required

JWT Token

Response

Import successfully created

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 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.configuration	object Organization configuration
organization.configuration.daysOfRetention	integer Data retention period in days.
organization.configuration.maxMonthlyVolumePerDataset	integer Maximum number of imports per dataset for this organization.
organization.configuration.maxDataset	integer Maximum number of datasets for this organization.
organization.configuration.maxMetadataPerDataset	integer Maximum number of metadata fields per dataset for this organization.
organization.configuration.augmentedSearchAccess	boolean True if this organization has access to the Augmented Search API.
organization.configuration.smartInsightAccess	boolean True if this organization has access to the Smart Insights API.
organization.configuration.aggregationAccess	boolean True if this organization has access to the Aggregation API.
organization.configuration.consoleAccess	boolean True if this organization has access to the Console.
organization.webhooks	array List of webhooks for organization

search

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

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

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

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

Path Params

Query Params

Body Params

Headers

200Response

Query Params

Headers

200Response

Body Params

Headers

201400Response

Path Params

Headers

200Response

Path Params

Headers

200400Response

Path Params

Headers

204400Response

Path Params

Headers

200404Response

Path Params

Headers

204404Response

Path Params

Query Params

Headers

200Response

Path Params

Body Params

Headers

201Response

Path Params

Headers

200404Response

Path Params

Query Params

Headers

200204404Response

Headers

200404Response

Path Params

Query Params

Body Params

Headers

200Response

Path Params

Query Params

Body Params

Headers

200Response

Body Params

200400Response

Headers

200404Response

Body Params

Headers

201404Response

Path Params

Body Params

Headers

200404Response

Path Params

Headers

204404Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response

Response