4Straction

The 4Straction Developer Hub

Welcome to the 4Straction developer hub.

This place is intended for technical audience. Here you'll find high level technical documentation how to consume 4straction api and detailed technical reference.

Get Started    
Suggest Edits

IntegrationDataMappingRule

 
 
puthttp://localhost/v1/IntegrationDataMappingRule/add
curl --request PUT \
  --url http://localhost/v1/IntegrationDataMappingRule/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/IntegrationDataMappingRule/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationDataMappingRule/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationDataMappingRule/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationDataMappingRule/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

DataMappingDimensionID
int32

reflection

SourceID
int32

reflection

MatchRuleID
int32

reflection

MatchRuleData
string

reflection

TargetRuleData
string

reflection

Sort
int32

reflection

DataMappingTypeID
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

delete

delete

 
gethttp://localhost/v1/IntegrationDataMappingRule/delete
curl --request GET \
  --url 'http://localhost/v1/IntegrationDataMappingRule/delete?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/IntegrationDataMappingRule/delete',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationDataMappingRule/delete?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationDataMappingRule/delete?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationDataMappingRule/delete"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

edit

edit

 
puthttp://localhost/v1/IntegrationDataMappingRule/edit
curl --request PUT \
  --url 'http://localhost/v1/IntegrationDataMappingRule/edit?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/IntegrationDataMappingRule/edit',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationDataMappingRule/edit?primaryKey=primaryKey")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationDataMappingRule/edit?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationDataMappingRule/edit"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Body Params

DataMappingDimensionID
int32

reflection

SourceID
int32

reflection

MatchRuleID
int32

reflection

MatchRuleData
string

reflection

TargetRuleData
string

reflection

Sort
int32

reflection

DataMappingTypeID
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/IntegrationDataMappingRule/loadAll
curl --request GET \
  --url http://localhost/v1/IntegrationDataMappingRule/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/IntegrationDataMappingRule/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationDataMappingRule/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationDataMappingRule/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationDataMappingRule/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

IntegrationDataMappingRule[]

Suggest Edits

CustomerComment

 
 
puthttp://localhost/v1/CustomerComment/add
curl --request PUT \
  --url http://localhost/v1/CustomerComment/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/CustomerComment/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CustomerComment/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CustomerComment/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CustomerComment/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

CustomerID
int32

reflection

UserID
int32

reflection

DateAdded
date-time

reflection

Comment
string

reflection

ReplyToCommentID
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/CustomerComment/loadAll
curl --request GET \
  --url http://localhost/v1/CustomerComment/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CustomerComment/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CustomerComment/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CustomerComment/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CustomerComment/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

CustomerComment[]

Suggest Edits

searchSlice

searchSlice

 
puthttp://localhost/v1/CustomerComment/searchSlice
curl --request PUT \
  --url http://localhost/v1/CustomerComment/searchSlice \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/CustomerComment/searchSlice',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CustomerComment/searchSlice")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CustomerComment/searchSlice");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CustomerComment/searchSlice"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Query Params

startID
int32

startID

maxCount
int32

maxCount

order
int32

order

Body Params

CustomerID
int32

reflection

UserID
int32

reflection

DateAdded
date-time

reflection

Comment
string

reflection

ReplyToCommentID
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

CustomerCommentPaginationSlice

Countinteger
TotalCountinteger
Orderinteger
NewCountinteger
NextIDinteger
Dataarray

Invalid input

Suggest Edits

UserCompanyAccess

 
 
puthttp://localhost/v1/UserCompanyAccess/add
curl --request PUT \
  --url http://localhost/v1/UserCompanyAccess/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/UserCompanyAccess/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/UserCompanyAccess/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/UserCompanyAccess/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/UserCompanyAccess/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

CompanyID
int32

reflection

UserID
int32

reflection

Added
date-time

reflection

IsUserAdministrator
int32

reflection

SystemUserTypeID
int32

reflection

ProfileID
int32

reflection

TemporaryAccess
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

searchAndEditCompanyAccess

searchAndEditCompanyAccess

 
puthttp://localhost/v1/UserCompanyAccess/searchAndEditCompanyAccess
curl --request PUT \
  --url http://localhost/v1/UserCompanyAccess/searchAndEditCompanyAccess \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/UserCompanyAccess/searchAndEditCompanyAccess',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/UserCompanyAccess/searchAndEditCompanyAccess")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/UserCompanyAccess/searchAndEditCompanyAccess");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/UserCompanyAccess/searchAndEditCompanyAccess"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

CompanyID
int32

reflection

UserID
int32

reflection

Added
date-time

reflection

IsUserAdministrator
int32

reflection

SystemUserTypeID
int32

reflection

ProfileID
int32

reflection

TemporaryAccess
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

loadCurrentCompanyAccesses

loadCurrentCompanyAccesses

 
gethttp://localhost/v1/UserCompanyAccess/loadCurrentCompanyAccesses
curl --request GET \
  --url http://localhost/v1/UserCompanyAccess/loadCurrentCompanyAccesses \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/UserCompanyAccess/loadCurrentCompanyAccesses',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/UserCompanyAccess/loadCurrentCompanyAccesses")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/UserCompanyAccess/loadCurrentCompanyAccesses");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/UserCompanyAccess/loadCurrentCompanyAccesses"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

UserCompanyAccess[]

Suggest Edits

loadMyAccess

loadMyAccess

 
gethttp://localhost/v1/UserCompanyAccess/loadMyAccess
curl --request GET \
  --url http://localhost/v1/UserCompanyAccess/loadMyAccess \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/UserCompanyAccess/loadMyAccess',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/UserCompanyAccess/loadMyAccess")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/UserCompanyAccess/loadMyAccess");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/UserCompanyAccess/loadMyAccess"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

UserCompanyAccessReport[]

Suggest Edits

loadCurrentUserAccesses

loadCurrentUserAccesses

 
gethttp://localhost/v1/UserCompanyAccess/loadCurrentUserAccesses
curl --request GET \
  --url http://localhost/v1/UserCompanyAccess/loadCurrentUserAccesses \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/UserCompanyAccess/loadCurrentUserAccesses',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/UserCompanyAccess/loadCurrentUserAccesses")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/UserCompanyAccess/loadCurrentUserAccesses");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/UserCompanyAccess/loadCurrentUserAccesses"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

UserCompanyAccessReport[]

Suggest Edits

changeCurrentCompany

changeCurrentCompany

 
gethttp://localhost/v1/UserCompanyAccess/changeCurrentCompany
curl --request GET \
  --url 'http://localhost/v1/UserCompanyAccess/changeCurrentCompany?toCompanyID=toCompanyID' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/UserCompanyAccess/changeCurrentCompany',
  qs: { toCompanyID: 'toCompanyID' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/UserCompanyAccess/changeCurrentCompany?toCompanyID=toCompanyID")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/UserCompanyAccess/changeCurrentCompany?toCompanyID=toCompanyID");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/UserCompanyAccess/changeCurrentCompany"

querystring = {"toCompanyID":"toCompanyID"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

toCompanyID
int32
required

toCompanyID

Headers

4S-API-App-ID
string
required

Response

UserCompanyAccess

CompanyIDinteger

reflection

UserIDinteger

reflection

Addedstring

reflection

IsUserAdministratorinteger

reflection

SystemUserTypeIDinteger

reflection

ProfileIDinteger

reflection

TemporaryAccessinteger

reflection

IDinteger

reflection

Suggest Edits

CompanyFunction

 
 
puthttp://localhost/v1/CompanyFunction/add
curl --request PUT \
  --url http://localhost/v1/CompanyFunction/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/CompanyFunction/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyFunction/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyFunction/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyFunction/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

FunctionTypeID
int32

reflection

FatherFunctionID
int32

reflection

Name
string

reflection

CompanyLegalEntityID
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

edit

edit

 
puthttp://localhost/v1/CompanyFunction/edit
curl --request PUT \
  --url 'http://localhost/v1/CompanyFunction/edit?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/CompanyFunction/edit',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyFunction/edit?primaryKey=primaryKey")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyFunction/edit?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyFunction/edit"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Body Params

FunctionTypeID
int32

reflection

FatherFunctionID
int32

reflection

Name
string

reflection

CompanyLegalEntityID
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

load

load

 
gethttp://localhost/v1/CompanyFunction/load
curl --request GET \
  --url 'http://localhost/v1/CompanyFunction/load?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CompanyFunction/load',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyFunction/load?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyFunction/load?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyFunction/load"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

CompanyFunction

FunctionTypeIDinteger

reflection

FatherFunctionIDinteger

reflection

Namestring

reflection

CompanyLegalEntityIDinteger

reflection

IDinteger

reflection

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/CompanyFunction/loadAll
curl --request GET \
  --url http://localhost/v1/CompanyFunction/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CompanyFunction/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyFunction/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyFunction/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyFunction/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

CompanyFunction[]

Suggest Edits

delete

delete

 
gethttp://localhost/v1/CompanyFunction/delete
curl --request GET \
  --url 'http://localhost/v1/CompanyFunction/delete?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CompanyFunction/delete',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyFunction/delete?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyFunction/delete?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyFunction/delete"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

CompanyLegalEntity

 
 
puthttp://localhost/v1/CompanyLegalEntity/add
curl --request PUT \
  --url http://localhost/v1/CompanyLegalEntity/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/CompanyLegalEntity/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyLegalEntity/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyLegalEntity/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyLegalEntity/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

Name
string

reflection

EntityTypeID
int32

reflection

FatherEntityID
int32

reflection

OrganizationIdentifier
string

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

edit

edit

 
puthttp://localhost/v1/CompanyLegalEntity/edit
curl --request PUT \
  --url 'http://localhost/v1/CompanyLegalEntity/edit?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/CompanyLegalEntity/edit',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyLegalEntity/edit?primaryKey=primaryKey")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyLegalEntity/edit?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyLegalEntity/edit"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Body Params

Name
string

reflection

EntityTypeID
int32

reflection

FatherEntityID
int32

reflection

OrganizationIdentifier
string

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

load

load

 
gethttp://localhost/v1/CompanyLegalEntity/load
curl --request GET \
  --url 'http://localhost/v1/CompanyLegalEntity/load?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CompanyLegalEntity/load',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyLegalEntity/load?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyLegalEntity/load?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyLegalEntity/load"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

CompanyLegalEntity

Namestring

reflection

EntityTypeIDinteger

reflection

FatherEntityIDinteger

reflection

OrganizationIdentifierstring

reflection

IDinteger

reflection

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/CompanyLegalEntity/loadAll
curl --request GET \
  --url http://localhost/v1/CompanyLegalEntity/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CompanyLegalEntity/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyLegalEntity/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyLegalEntity/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyLegalEntity/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

CompanyLegalEntity[]

Suggest Edits

delete

delete

 
gethttp://localhost/v1/CompanyLegalEntity/delete
curl --request GET \
  --url 'http://localhost/v1/CompanyLegalEntity/delete?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/CompanyLegalEntity/delete',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/CompanyLegalEntity/delete?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/CompanyLegalEntity/delete?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/CompanyLegalEntity/delete"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

IntegrationPipedriveSettings

 
Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/IntegrationPipedriveSettings/loadAll
curl --request GET \
  --url http://localhost/v1/IntegrationPipedriveSettings/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/IntegrationPipedriveSettings/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationPipedriveSettings/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationPipedriveSettings/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationPipedriveSettings/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

IntegrationPipedriveSettings[]

Suggest Edits

IntegrationPipedriveSettingsPipeline

 
Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/IntegrationPipedriveSettingsPipeline/loadAll
curl --request GET \
  --url http://localhost/v1/IntegrationPipedriveSettingsPipeline/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/IntegrationPipedriveSettingsPipeline/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationPipedriveSettingsPipeline/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationPipedriveSettingsPipeline/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationPipedriveSettingsPipeline/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

IntegrationPipedriveSettingsPipeline[]

Suggest Edits

IntegrationPipedriveSettingsPipelineStage

 
Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/IntegrationPipedriveSettingsPipelineStage/loadAll
curl --request GET \
  --url http://localhost/v1/IntegrationPipedriveSettingsPipelineStage/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/IntegrationPipedriveSettingsPipelineStage/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/IntegrationPipedriveSettingsPipelineStage/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/IntegrationPipedriveSettingsPipelineStage/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/IntegrationPipedriveSettingsPipelineStage/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

IntegrationPipedriveSettingsPipelineStage[]

Suggest Edits

Competitor

 
 
puthttp://localhost/v1/Competitor/add
curl --request PUT \
  --url http://localhost/v1/Competitor/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Competitor/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

edit

edit

 
puthttp://localhost/v1/Competitor/edit
curl --request PUT \
  --url http://localhost/v1/Competitor/edit \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Competitor/edit',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/edit")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/edit");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/edit"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

setupNewsSources

setupNewsSources

 
puthttp://localhost/v1/Competitor/setupNewsSources
curl --request PUT \
  --url http://localhost/v1/Competitor/setupNewsSources \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Competitor/setupNewsSources',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/setupNewsSources")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/setupNewsSources");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/setupNewsSources"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

load

load

 
gethttp://localhost/v1/Competitor/load
curl --request GET \
  --url 'http://localhost/v1/Competitor/load?entityID=entityID' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/load',
  qs: { entityID: 'entityID' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/load?entityID=entityID")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/load?entityID=entityID");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/load"

querystring = {"entityID":"entityID"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

entityID
int32
required

entityID

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CompetitorReport

Commentsobject
Comments.Countinteger
Comments.TotalCountinteger
Comments.Orderinteger
Comments.NewCountinteger
Comments.NextIDinteger
Comments.Dataarray
TypeIDinteger

reflection

BusinessIDstring

reflection

HumanReadableBusinessIDstring

reflection

DomainURIstring

reflection

CreatorIDinteger

reflection

DateAddedstring

reflection

DateRemovedstring

reflection

LocationLatitudenumber

reflection

LocationLongitudenumber

reflection

MarketScopeTypeIDinteger

reflection

MarketScopeEntityIDstring

reflection

CountryIDinteger

reflection

Descriptionstring

reflection

Importanceinteger

reflection

AddressLinestring

reflection

BrandNamesstring

reflection

NewsWatchOninteger

reflection

NewsWatchFilterLevelIDinteger

reflection

NewsWatchInitialRunDoneinteger

reflection

AdditionalMarketIDinteger

reflection

NewsModeratorIDinteger

reflection

WebWatchOnboolean

reflection

TwitterWatchOnboolean

reflection

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/Competitor/loadAll
curl --request GET \
  --url http://localhost/v1/Competitor/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

sortColumn
string

sortColumn

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CompetitorReport[]

Suggest Edits

getNewsPreview

getNewsPreview

 
gethttp://localhost/v1/Competitor/getNewsPreview
curl --request GET \
  --url 'http://localhost/v1/Competitor/getNewsPreview?playerId=playerId&strictnessLevel=strictnessLevel&brandNames=brandNames&newsSearch=newsSearch&webSearch=webSearch&includeEnglishMarket=includeEnglishMarket&maxItems=maxItems' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/getNewsPreview',
  qs: 
   { playerId: 'playerId',
     strictnessLevel: 'strictnessLevel',
     brandNames: 'brandNames',
     newsSearch: 'newsSearch',
     webSearch: 'webSearch',
     includeEnglishMarket: 'includeEnglishMarket',
     maxItems: 'maxItems' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/getNewsPreview?playerId=playerId&strictnessLevel=strictnessLevel&brandNames=brandNames&newsSearch=newsSearch&webSearch=webSearch&includeEnglishMarket=includeEnglishMarket&maxItems=maxItems")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/getNewsPreview?playerId=playerId&strictnessLevel=strictnessLevel&brandNames=brandNames&newsSearch=newsSearch&webSearch=webSearch&includeEnglishMarket=includeEnglishMarket&maxItems=maxItems");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/getNewsPreview"

querystring = {"playerId":"playerId","strictnessLevel":"strictnessLevel","brandNames":"brandNames","newsSearch":"newsSearch","webSearch":"webSearch","includeEnglishMarket":"includeEnglishMarket","maxItems":"maxItems"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

playerId
int32
required

playerId

strictnessLevel
int32
required

strictnessLevel

brandNames
string
required

brandNames

newsSearch
boolean
required

newsSearch

webSearch
boolean
required

webSearch

includeEnglishMarket
boolean
required

includeEnglishMarket

maxItems
int32
required

maxItems

Headers

4S-API-App-ID
string
required

Response

BingCognitiveItem[]

Suggest Edits

getAutomatedSourcesPreview

getAutomatedSourcesPreview

 
gethttp://localhost/v1/Competitor/getAutomatedSourcesPreview
curl --request GET \
  --url 'http://localhost/v1/Competitor/getAutomatedSourcesPreview?businessID=businessID&startDate=0001-01-01T00%3A00%3A00&endDate=0001-01-01T00%3A00%3A00' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/getAutomatedSourcesPreview',
  qs: 
   { businessID: 'businessID',
     startDate: '0001-01-01T00:00:00',
     endDate: '0001-01-01T00:00:00' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/getAutomatedSourcesPreview?businessID=businessID&startDate=0001-01-01T00%3A00%3A00&endDate=0001-01-01T00%3A00%3A00")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/getAutomatedSourcesPreview?businessID=businessID&startDate=0001-01-01T00%3A00%3A00&endDate=0001-01-01T00%3A00%3A00");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/getAutomatedSourcesPreview"

querystring = {"businessID":"businessID","startDate":"0001-01-01T00:00:00","endDate":"0001-01-01T00:00:00"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

businessID
string
required

businessID

startDate
date-time
required

startDate

endDate
date-time
required

endDate

Headers

4S-API-App-ID
string
required

Response

AutomatedSourceGeneratedNews[]

Suggest Edits

processInitialNewsSearch

processInitialNewsSearch

 
puthttp://localhost/v1/Competitor/processInitialNewsSearch
curl --request PUT \
  --url http://localhost/v1/Competitor/processInitialNewsSearch \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Competitor/processInitialNewsSearch',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/processInitialNewsSearch")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/processInitialNewsSearch");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/processInitialNewsSearch"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

processDailyNewsChangesForAll

processDailyNewsChangesForAll

 
gethttp://localhost/v1/Competitor/processDailyNewsChangesForAll
curl --request GET \
  --url http://localhost/v1/Competitor/processDailyNewsChangesForAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/processDailyNewsChangesForAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/processDailyNewsChangesForAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/processDailyNewsChangesForAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/processDailyNewsChangesForAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

delete

delete

 
gethttp://localhost/v1/Competitor/delete
curl --request GET \
  --url 'http://localhost/v1/Competitor/delete?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/delete',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/delete?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/delete?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/delete"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

dummy

dummy

 
gethttp://localhost/v1/Competitor/dummy
curl --request GET \
  --url http://localhost/v1/Competitor/dummy \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/dummy',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/dummy")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/dummy");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/dummy"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

MarketPlayerBase

BusinessIDstring

reflection

HumanReadableBusinessIDstring

reflection

DomainURIstring

reflection

CreatorIDinteger

reflection

DateAddedstring

reflection

DateRemovedstring

reflection

LocationLatitudenumber

reflection

LocationLongitudenumber

reflection

MarketScopeTypeIDinteger

reflection

MarketScopeEntityIDstring

reflection

CountryIDinteger

reflection

Descriptionstring

reflection

Importanceinteger

reflection

AddressLinestring

reflection

BrandNamesstring

reflection

NewsWatchOninteger

reflection

NewsWatchFilterLevelIDinteger

reflection

NewsWatchInitialRunDoneinteger

reflection

AdditionalMarketIDinteger

reflection

NewsModeratorIDinteger

reflection

WebWatchOnboolean

reflection

TwitterWatchOnboolean

reflection

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadReport

loadReport

 
gethttp://localhost/v1/Competitor/loadReport
curl --request GET \
  --url 'http://localhost/v1/Competitor/loadReport?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/loadReport',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/loadReport?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/loadReport?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/loadReport"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CompetitorReport

Commentsobject
Comments.Countinteger
Comments.TotalCountinteger
Comments.Orderinteger
Comments.NewCountinteger
Comments.NextIDinteger
Comments.Dataarray
TypeIDinteger

reflection

BusinessIDstring

reflection

HumanReadableBusinessIDstring

reflection

DomainURIstring

reflection

CreatorIDinteger

reflection

DateAddedstring

reflection

DateRemovedstring

reflection

LocationLatitudenumber

reflection

LocationLongitudenumber

reflection

MarketScopeTypeIDinteger

reflection

MarketScopeEntityIDstring

reflection

CountryIDinteger

reflection

Descriptionstring

reflection

Importanceinteger

reflection

AddressLinestring

reflection

BrandNamesstring

reflection

NewsWatchOninteger

reflection

NewsWatchFilterLevelIDinteger

reflection

NewsWatchInitialRunDoneinteger

reflection

AdditionalMarketIDinteger

reflection

NewsModeratorIDinteger

reflection

WebWatchOnboolean

reflection

TwitterWatchOnboolean

reflection

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadReportAll

loadReportAll

 
gethttp://localhost/v1/Competitor/loadReportAll
curl --request GET \
  --url http://localhost/v1/Competitor/loadReportAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Competitor/loadReportAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Competitor/loadReportAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Competitor/loadReportAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Competitor/loadReportAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CompetitorReport[]

 
 
puthttp://localhost/v1/Customer/add
curl --request PUT \
  --url http://localhost/v1/Customer/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Customer/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

edit

edit

 
puthttp://localhost/v1/Customer/edit
curl --request PUT \
  --url http://localhost/v1/Customer/edit \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Customer/edit',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/edit")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/edit");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/edit"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

setupNewsSources

setupNewsSources

 
puthttp://localhost/v1/Customer/setupNewsSources
curl --request PUT \
  --url http://localhost/v1/Customer/setupNewsSources \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Customer/setupNewsSources',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/setupNewsSources")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/setupNewsSources");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/setupNewsSources"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

load

load

 
gethttp://localhost/v1/Customer/load
curl --request GET \
  --url 'http://localhost/v1/Customer/load?entityID=entityID' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/load',
  qs: { entityID: 'entityID' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/load?entityID=entityID")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/load?entityID=entityID");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/load"

querystring = {"entityID":"entityID"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

entityID
int32
required

entityID

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CustomerReport

Commentsobject
Comments.Countinteger
Comments.TotalCountinteger
Comments.Orderinteger
Comments.NewCountinteger
Comments.NextIDinteger
Comments.Dataarray
TypeIDinteger

reflection

BusinessIDstring

reflection

HumanReadableBusinessIDstring

reflection

DomainURIstring

reflection

CreatorIDinteger

reflection

DateAddedstring

reflection

DateRemovedstring

reflection

LocationLatitudenumber

reflection

LocationLongitudenumber

reflection

MarketScopeTypeIDinteger

reflection

MarketScopeEntityIDstring

reflection

CountryIDinteger

reflection

Descriptionstring

reflection

Importanceinteger

reflection

AddressLinestring

reflection

BrandNamesstring

reflection

NewsWatchOninteger

reflection

NewsWatchFilterLevelIDinteger

reflection

NewsWatchInitialRunDoneinteger

reflection

AdditionalMarketIDinteger

reflection

NewsModeratorIDinteger

reflection

WebWatchOnboolean

reflection

TwitterWatchOnboolean

reflection

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/Customer/loadAll
curl --request GET \
  --url http://localhost/v1/Customer/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

sortColumn
string

sortColumn

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CustomerReport[]

Suggest Edits

getNewsPreview

getNewsPreview

 
gethttp://localhost/v1/Customer/getNewsPreview
curl --request GET \
  --url 'http://localhost/v1/Customer/getNewsPreview?playerId=playerId&strictnessLevel=strictnessLevel&brandNames=brandNames&newsSearch=newsSearch&webSearch=webSearch&includeEnglishMarket=includeEnglishMarket&maxItems=maxItems' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/getNewsPreview',
  qs: 
   { playerId: 'playerId',
     strictnessLevel: 'strictnessLevel',
     brandNames: 'brandNames',
     newsSearch: 'newsSearch',
     webSearch: 'webSearch',
     includeEnglishMarket: 'includeEnglishMarket',
     maxItems: 'maxItems' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/getNewsPreview?playerId=playerId&strictnessLevel=strictnessLevel&brandNames=brandNames&newsSearch=newsSearch&webSearch=webSearch&includeEnglishMarket=includeEnglishMarket&maxItems=maxItems")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/getNewsPreview?playerId=playerId&strictnessLevel=strictnessLevel&brandNames=brandNames&newsSearch=newsSearch&webSearch=webSearch&includeEnglishMarket=includeEnglishMarket&maxItems=maxItems");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/getNewsPreview"

querystring = {"playerId":"playerId","strictnessLevel":"strictnessLevel","brandNames":"brandNames","newsSearch":"newsSearch","webSearch":"webSearch","includeEnglishMarket":"includeEnglishMarket","maxItems":"maxItems"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

playerId
int32
required

playerId

strictnessLevel
int32
required

strictnessLevel

brandNames
string
required

brandNames

newsSearch
boolean
required

newsSearch

webSearch
boolean
required

webSearch

includeEnglishMarket
boolean
required

includeEnglishMarket

maxItems
int32
required

maxItems

Headers

4S-API-App-ID
string
required

Response

BingCognitiveItem[]

Suggest Edits

getAutomatedSourcesPreview

getAutomatedSourcesPreview

 
gethttp://localhost/v1/Customer/getAutomatedSourcesPreview
curl --request GET \
  --url 'http://localhost/v1/Customer/getAutomatedSourcesPreview?businessID=businessID&startDate=0001-01-01T00%3A00%3A00&endDate=0001-01-01T00%3A00%3A00' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/getAutomatedSourcesPreview',
  qs: 
   { businessID: 'businessID',
     startDate: '0001-01-01T00:00:00',
     endDate: '0001-01-01T00:00:00' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/getAutomatedSourcesPreview?businessID=businessID&startDate=0001-01-01T00%3A00%3A00&endDate=0001-01-01T00%3A00%3A00")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/getAutomatedSourcesPreview?businessID=businessID&startDate=0001-01-01T00%3A00%3A00&endDate=0001-01-01T00%3A00%3A00");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/getAutomatedSourcesPreview"

querystring = {"businessID":"businessID","startDate":"0001-01-01T00:00:00","endDate":"0001-01-01T00:00:00"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

businessID
string
required

businessID

startDate
date-time
required

startDate

endDate
date-time
required

endDate

Headers

4S-API-App-ID
string
required

Response

AutomatedSourceGeneratedNews[]

Suggest Edits

processInitialNewsSearch

processInitialNewsSearch

 
puthttp://localhost/v1/Customer/processInitialNewsSearch
curl --request PUT \
  --url http://localhost/v1/Customer/processInitialNewsSearch \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Customer/processInitialNewsSearch',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/processInitialNewsSearch")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/processInitialNewsSearch");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/processInitialNewsSearch"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

TypeID
int32

reflection

BusinessID
string

reflection

HumanReadableBusinessID
string

reflection

DomainURI
string

reflection

CreatorID
int32

reflection

DateAdded
date-time

reflection

DateRemoved
date-time

reflection

LocationLatitude
double

reflection

LocationLongitude
double

reflection

MarketScopeTypeID
int32

reflection

MarketScopeEntityID
string

reflection

CountryID
int32

reflection

Description
string

reflection

Importance
int32

reflection

AddressLine
string

reflection

BrandNames
string

reflection

NewsWatchOn
int32

reflection

NewsWatchFilterLevelID
int32

reflection

NewsWatchInitialRunDone
int32

reflection

AdditionalMarketID
int32

reflection

NewsModeratorID
int32

reflection

WebWatchOn
boolean

reflection

TwitterWatchOn
boolean

reflection

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

processDailyNewsChangesForAll

processDailyNewsChangesForAll

 
gethttp://localhost/v1/Customer/processDailyNewsChangesForAll
curl --request GET \
  --url http://localhost/v1/Customer/processDailyNewsChangesForAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/processDailyNewsChangesForAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/processDailyNewsChangesForAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/processDailyNewsChangesForAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/processDailyNewsChangesForAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

delete

delete

 
gethttp://localhost/v1/Customer/delete
curl --request GET \
  --url 'http://localhost/v1/Customer/delete?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/delete',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/delete?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/delete?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/delete"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

dummy

dummy

 
gethttp://localhost/v1/Customer/dummy
curl --request GET \
  --url http://localhost/v1/Customer/dummy \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/dummy',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/dummy")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/dummy");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/dummy"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

MarketPlayerBase

BusinessIDstring

reflection

HumanReadableBusinessIDstring

reflection

DomainURIstring

reflection

CreatorIDinteger

reflection

DateAddedstring

reflection

DateRemovedstring

reflection

LocationLatitudenumber

reflection

LocationLongitudenumber

reflection

MarketScopeTypeIDinteger

reflection

MarketScopeEntityIDstring

reflection

CountryIDinteger

reflection

Descriptionstring

reflection

Importanceinteger

reflection

AddressLinestring

reflection

BrandNamesstring

reflection

NewsWatchOninteger

reflection

NewsWatchFilterLevelIDinteger

reflection

NewsWatchInitialRunDoneinteger

reflection

AdditionalMarketIDinteger

reflection

NewsModeratorIDinteger

reflection

WebWatchOnboolean

reflection

TwitterWatchOnboolean

reflection

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadReport

loadReport

 
gethttp://localhost/v1/Customer/loadReport
curl --request GET \
  --url 'http://localhost/v1/Customer/loadReport?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/loadReport',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/loadReport?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/loadReport?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/loadReport"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CustomerReport

Commentsobject
Comments.Countinteger
Comments.TotalCountinteger
Comments.Orderinteger
Comments.NewCountinteger
Comments.NextIDinteger
Comments.Dataarray
TypeIDinteger

reflection

BusinessIDstring

reflection

HumanReadableBusinessIDstring

reflection

DomainURIstring

reflection

CreatorIDinteger

reflection

DateAddedstring

reflection

DateRemovedstring

reflection

LocationLatitudenumber

reflection

LocationLongitudenumber

reflection

MarketScopeTypeIDinteger

reflection

MarketScopeEntityIDstring

reflection

CountryIDinteger

reflection

Descriptionstring

reflection

Importanceinteger

reflection

AddressLinestring

reflection

BrandNamesstring

reflection

NewsWatchOninteger

reflection

NewsWatchFilterLevelIDinteger

reflection

NewsWatchInitialRunDoneinteger

reflection

AdditionalMarketIDinteger

reflection

NewsModeratorIDinteger

reflection

WebWatchOnboolean

reflection

TwitterWatchOnboolean

reflection

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadReportAll

loadReportAll

 
gethttp://localhost/v1/Customer/loadReportAll
curl --request GET \
  --url http://localhost/v1/Customer/loadReportAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Customer/loadReportAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Customer/loadReportAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Customer/loadReportAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Customer/loadReportAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

maxCommentsCount
int32

maxCommentsCount

Headers

4S-API-App-ID
string
required

Response

CustomerReport[]

Suggest Edits

NewsEntryUserStatus

 
Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/NewsEntryUserStatus/loadAll
curl --request GET \
  --url http://localhost/v1/NewsEntryUserStatus/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/NewsEntryUserStatus/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/NewsEntryUserStatus/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/NewsEntryUserStatus/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/NewsEntryUserStatus/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

NewsEntryUserStatus[]

Suggest Edits

NewsEntryEntryStatus

 
Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/NewsEntryEntryStatus/loadAll
curl --request GET \
  --url http://localhost/v1/NewsEntryEntryStatus/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/NewsEntryEntryStatus/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/NewsEntryEntryStatus/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/NewsEntryEntryStatus/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/NewsEntryEntryStatus/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

4S-API-App-ID
string
required

Response

NewsEntryEntryStatus[]

 
Suggest Edits

load

load

 
gethttp://localhost/v1/GeoArea/load
curl --request GET \
  --url 'http://localhost/v1/GeoArea/load?primaryKey=primaryKey' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/GeoArea/load',
  qs: { primaryKey: 'primaryKey' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/GeoArea/load?primaryKey=primaryKey")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/GeoArea/load?primaryKey=primaryKey");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/GeoArea/load"

querystring = {"primaryKey":"primaryKey"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

primaryKey
int32
required

primaryKey

Headers

4S-API-App-ID
string
required

Response

GeoArea

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/GeoArea/loadAll
curl --request GET \
  --url http://localhost/v1/GeoArea/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/GeoArea/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/GeoArea/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/GeoArea/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/GeoArea/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

sortColumn
string

sortColumn

Headers

4S-API-App-ID
string
required

Response

GeoArea[]

 
 
puthttp://localhost/v1/Product/add
curl --request PUT \
  --url http://localhost/v1/Product/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Product/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Product/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Product/add");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Product/add"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

integer:int32

Invalid input

Suggest Edits

edit

edit

 
puthttp://localhost/v1/Product/edit
curl --request PUT \
  --url http://localhost/v1/Product/edit \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/Product/edit',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Product/edit")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Product/edit");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Product/edit"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

Body Params

Name
string

reflection

FatherID
int32

reflection

Sort
int32

reflection

ScopeEndSort
int32

reflection

DepthLevel
int32

reflection

IsGroup
int32

reflection

ID
int32

reflection

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Invalid input

Suggest Edits

load

load

 
gethttp://localhost/v1/Product/load
curl --request GET \
  --url 'http://localhost/v1/Product/load?entityID=entityID' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Product/load',
  qs: { entityID: 'entityID' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Product/load?entityID=entityID")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Product/load?entityID=entityID");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Product/load"

querystring = {"entityID":"entityID"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

entityID
int32
required

entityID

Headers

4S-API-App-ID
string
required

Response

Product

Namestring

reflection

FatherIDinteger

reflection

Sortinteger

reflection

ScopeEndSortinteger

reflection

DepthLevelinteger

reflection

IsGroupinteger

reflection

IDinteger

reflection

Suggest Edits

loadAll

loadAll

 
gethttp://localhost/v1/Product/loadAll
curl --request GET \
  --url http://localhost/v1/Product/loadAll \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Product/loadAll',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Product/loadAll")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Product/loadAll");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Product/loadAll"

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

sortColumn
string

sortColumn

Headers

4S-API-App-ID
string
required

Response

Product[]

Suggest Edits

delete

delete

 
gethttp://localhost/v1/Product/delete
curl --request GET \
  --url 'http://localhost/v1/Product/delete?entityID=entityID' \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'GET',
  url: 'http://localhost/v1/Product/delete',
  qs: { entityID: 'entityID' },
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/Product/delete?entityID=entityID")

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

request = Net::HTTP::Get.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/Product/delete?entityID=entityID");
xhr.setRequestHeader("4s-api-app-id", "4S-API-App-ID");

xhr.send(data);
import requests

url = "http://localhost/v1/Product/delete"

querystring = {"entityID":"entityID"}

headers = {'4s-api-app-id': '4S-API-App-ID'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

entityID
int32
required

entityID

Headers

4S-API-App-ID
string
required

Response

Method does not return a value

Suggest Edits

OtherPlayerComment

 
 
puthttp://localhost/v1/OtherPlayerComment/add
curl --request PUT \
  --url http://localhost/v1/OtherPlayerComment/add \
  --header '4s-api-app-id: 4S-API-App-ID'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://localhost/v1/OtherPlayerComment/add',
  headers: { '4s-api-app-id': '4S-API-App-ID' } };

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

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://localhost/v1/OtherPlayerComment/add")

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

request = Net::HTTP::Put.new(url)
request["4s-api-app-id"] = '4S-API-App-ID'

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", "http://localhost/v1/OtherPlayerComment/add");
xhr.