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

createdAtstring

Dataset creation date

updatedAtstring

Dataset last update date

documentsCountinteger

Current number of 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

createdAtstring

Dataset creation date

updatedAtstring

Dataset last update date

documentsCountinteger

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

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

Dataset analyze launched (async handling)

Unable to analyze 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

lastDocumentClassificationstring

Document last classification 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 launched (async handling)

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

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

JWT Token

Response

OK

packageobject
package.codestring
package.namestring
package.documentQuotainteger
package.daysOfRetentioninteger
package.maxDatasetinteger
package.maxMetadataPerDatasetinteger
package.blockedboolean
startDatestring
endDatestring

Organization not found

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

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

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

JWT Token

Response

OK

startDatestring
endDatestring
debitedinteger
creditedinteger

Organization not found

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

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.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

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

No topics found

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

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

You couldn't be authenticated

Try the API to see results

Path Params

webhookEvent
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

Organization not found

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

You couldn't be authenticated

Try the API to see results

Path Params

webhookEvent
string
required
responseId
string
required

Headers

Authorization
string
required

JWT Token

Response

OK

idstring

Webhook response id

eventstring

Webhook event

triggeredAtstring

The time this event was triggered

statusCodeinteger

Status code of the request, -1 means target url couldn't be reached.

requestobject

Request data

request.headersstring

Headers

request.contentstring

Content

replyobject

Reply data

reply.headersstring

Headers

reply.contentstring

Content

reply.statusCodeinteger

Reply status code

Organization not found