Dictanova Developer Portal

Empower your data with semantic analysis. Integrate new features of customer feedback analysis with the Dictanova API.

Get Started

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Query Params

q
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
to
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

fieldstring

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

typestring

Type of aggregation

periodsarray

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

page
int32
pageSize
int32

Headers

Authorization
string
required

JWT Token

Response

OK

pageinteger

Current page (start with 1 index)

pageSizeinteger

Current page size (default to 20 items)

totalinteger

Total number of items

itemsarray

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)
A binary file was returned

You couldn't be authenticated

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

namestring

Dataset name

langstring

Dataset lang

typestring

Dataset type

industrystring

Dataset industry

daysOfRetentioninteger

Data retention period in days (override default from organisation)

metadataDefinitionsarray

Dataset metadata

idstring

Dataset id

statestring

Dataset state

createdAtstring

Dataset creation date

updatedAtstring

Dataset last update date

monthlyImportedDocumentsarray

Dataset monthly counter of imported documents

Unable to create dataset

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Headers

Authorization
string
required

JWT Token

Response

OK

namestring

Dataset name

langstring

Dataset lang

typestring

Dataset type

industrystring

Dataset industry

daysOfRetentioninteger

Data retention period in days (override default from organisation)

metadataDefinitionsarray

Dataset metadata

idstring

Dataset id

statestring

Dataset state

createdAtstring

Dataset creation date

updatedAtstring

Dataset last update date

monthlyImportedDocumentsarray

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Headers

Authorization
string
required

JWT Token

Response

Analyze successfully launched

Unable to analyze dataset

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Headers

Authorization
string
required

JWT Token

Response

Dataset successfully archived

Unable to archive dataset

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required
externalId
string
required

Headers

Authorization
string
required

JWT Token

Response

OK

externalIdstring

Document id provided by client

langstring

Document lang

typestring

Document data type

contentstring

Document text content

metadataarray

Document metadata

idstring

Document id

createdAtstring

Document creation date

updatedAtstring

Document last update date

statestring

Document state

enrichmentsarray

Document enrichments

lastOpinionEnrichmentstring

Document last opinion enrichment date

Import not found

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required
externalId
string
required

Headers

Authorization
string
required

JWT Token

Response

Document successfully deleted

Import not found

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Query Params

page
int32
pageSize
int32

Headers

Authorization
string
required

JWT Token

Response

OK

pageinteger

Current page (start with 1 index)

pageSizeinteger

Current page size (default to 20 items)

totalinteger

Total number of items

itemsarray

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)
A binary file was returned

You couldn't be authenticated

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

idstring

Import id

createdAtstring

Import creation date

updatedAtstring

Import last update date

endedAtstring

Import end date

statestring

Import state

totalDocumentsinteger

Total documents

processedDocumentsinteger

Processed documents

totalErrorsinteger

Total of import errors

errorsarray

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required
importId
string
required

Headers

Authorization
string
required

JWT Token

Response

OK

idstring

Import id

createdAtstring

Import creation date

updatedAtstring

Import last update date

endedAtstring

Import end date

statestring

Import state

totalDocumentsinteger

Total documents

processedDocumentsinteger

Processed documents

totalErrorsinteger

Total of import errors

errorsarray

Import errors

Import not found

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)
A binary file was returned

You couldn't be authenticated

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

OK

pageinteger

Current page (start with 1 index)

pageSizeinteger

Current page size (default to 20 items)

totalinteger

Total number of items

itemsarray

Items for current page

Import not ready

Import not found

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

JWT Token

Response

OK

clientIdstring

Client Identifier

organizationobject

Client organization info

organization.idstring

Organization id

organization.namestring

Organization name

organization.createdAtstring

Organization creation date

organization.updatedAtstring

Organization last update date

organization.statestring

Organization state

organization.configurationobject

Organization configuration

organization.configuration.daysOfRetentioninteger

Data retention period in days.

organization.configuration.maxMonthlyVolumePerDatasetinteger

Maximum number of imports per dataset for this organization.

organization.configuration.maxDatasetinteger

Maximum number of datasets for this organization.

organization.configuration.maxMetadataPerDatasetinteger

Maximum number of metadata fields per dataset for this organization.

organization.configuration.augmentedSearchAccessboolean

True if this organization has access to the Augmented Search API.

organization.configuration.smartInsightAccessboolean

True if this organization has access to the Smart Insights API.

organization.configuration.aggregationAccessboolean

True if this organization has access to the Aggregation API.

organization.configuration.consoleAccessboolean

True if this organization has access to the Console.

organization.webhooksarray

List of webhooks for organization

Client not found.

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Query Params

q
string
page
int32
pageSize
int32
sortBy
string
sortOrder
string

Body Params

operator
string

Headers

Authorization
string
required

JWT Token

Response

Search OK

pageinteger

Current page (start with 1 index)

pageSizeinteger

Current page size (default to 20 items)

totalinteger

Total number of items

itemsarray

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

datasetId
string
required

Query Params

page
int32
pageSize
int32
sortOrder
string
q
string
opinions
array of strings

Body Params

operator
string

Headers

Authorization
string
required

JWT Token

Response

Search OK

pageinteger

Current page (start with 1 index)

pageSizeinteger

Current page size (default to 20 items)

totalinteger

Total number of items

itemsarray

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

clientId
string
clientSecret
string

Response

OK

access_tokenstring
token_typestring
expires_ininteger

Invalid request

successboolean

This is an error

errorsarray

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

JWT Token

Response

OK

Organization not found

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)
A binary file was returned

You couldn't be authenticated

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

Organization not found

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)
A binary file was returned

You couldn't be authenticated

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

Organization not found

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)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

webhookEvent
string
required

Headers

Authorization
string
required

JWT Token

Response

Webhook deleted

Organization not found