Front Systems Webshop API

The FS-WebshopApi Developer Hub

Welcome to the Front Systems developer hub. You'll find comprehensive guides and documentation to help you start working with the webshop api as quickly as possible, as well as support if you get stuck. Let's jump right in!

Get Started    
Suggest Edits

/api/Bonus

 
post/api/Bonus
curl --request POST \
  --url http://example.com/api/Bonus \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Bonus',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Bonus")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Bonus");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Bonus"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

customerId
int32
amount
int32
comment
string
saleId
int32

Headers

Authorization
string
required

access token

Response

Success

 

Customer endpoints

Minimum parameters

{
  "pageSize": 3000,
  "pageSkip": 0
}

Search for customers with email

{
  "emailContains": "post@frontsystems.no"
}

Search for customer with a specific name

{
  "firstNameContains": "Bender",
  "lastNameContains": "Rodriguez" 
}

Search for customers within a specific postal code range, here for Oslo

{
  "pageSize": 3000,
  "pageSkip": 0,
  "postalCodeGreaterThan": "0000",
  "postalCodeLessThan": "1299",
}
Suggest Edits

/api/Customer

 
putexample.com/api/Customer
curl --request PUT \
  --url http://example.com/api/Customer \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/Customer',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Customer")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://example.com/api/Customer");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Customer"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

customerid
int32
companyid_fk
int32
isCompany
boolean
companyName
string
orgNum
string
firstName
string
lastName
string
email
string
phone
string
address
string
postalCode
string
city
string
countryFk
int32
langCode
string
password
string
pin
string
ins
date-time
picture
byte
despcription
string
message
string
stdDiscount
double
altPersonId
string
isActive
boolean
deleted
boolean
isGlobal
boolean
agreedSendEmail
boolean
agreedSendSms
boolean
tags
string
birthYear
int32
birthDay
date-time
gender
string
isInvoice
boolean
extId
string
cardNo
string
upt
date-time
uptBy
int32
insBy
int32
suppressCampaigns
boolean
bonusBalance
int32
bonusTotal
int32
bonusFactor
double
isEmployee
boolean
saleBonusFactor
double
registeredStoreId
int32
extProperties
string
gdprUpdated
date-time

Headers

Authorization
string
required

access token

Response

Success

When you upsert a customer it will first try to identify based on Customerid (if present), then Email and then lastly Phone number.

You will get our Customerid in return on a successful upsert.

 var client = new HttpClient();


                client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);

                var content =
                   new StringContent(JsonConvert.SerializeObject(new
               {
                   FirstName = "Karl Einar",
                   LastName = "Kaalstad",
                   Email = "karl@frontsystems.no",
                   Address = "Arnstein Arnebergs vei 30",
                   PostalCode = "1366",
                   City = "Lysaker",
                   Phone = "47203036"
               }), Encoding.UTF8, "application/json");

                var response = await client.PutAsync($"{baseurl}customer", content);

                return await response.Content.ReadAsStringAsync();
Suggest Edits

/api/Customer

 
postexample.com/api/Customer
curl --request POST \
  --url http://example.com/api/Customer \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Customer',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Customer")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Customer");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Customer"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

pageSize
int32
pageSkip
int32
upt
date-time
storeIds
array of integers
firstNameContains
string
lastNameContains
string
emailContains
string
phoneContains
string
postalCodeGreaterThan
string
postalCodeLessThan
string
companyNameContains
string
hasBonus
boolean
hasDiscount
boolean
isEmployee
boolean
isCompany
boolean

Headers

Authorization
string
required

access token

Response

Success

This is the body I can change.

Suggest Edits

/api/Customer/count

 
postexample.com/api/Customer/count
curl --request POST \
  --url http://example.com/api/Customer/count \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Customer/count',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Customer/count")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Customer/count");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Customer/count"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

pageSize
int32
pageSkip
int32
upt
date-time
storeIds
array of integers
firstNameContains
string
lastNameContains
string
emailContains
string
phoneContains
string
postalCodeGreaterThan
string
postalCodeLessThan
string
companyNameContains
string
hasBonus
boolean
hasDiscount
boolean
isEmployee
boolean
isCompany
boolean

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Customer/{customerid}

 
deleteexample.com/api/Customer/customerid
curl --request DELETE \
  --url http://example.com/api/Customer/customerid \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'DELETE',
  url:
   'http://example.com/api/Customer/customerid',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Customer/customerid")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("DELETE", "http://example.com/api/Customer/customerid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Customer/customerid"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

customerid
int32
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Customer/optin/{customerid}

 
getexample.com/api/Customer/optin/customerid
curl --request GET \
  --url http://example.com/api/Customer/optin/customerid \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Customer/optin/customerid',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Customer/optin/customerid")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Customer/optin/customerid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Customer/optin/customerid"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

customerid
int32
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Customer/optout/{customerid}

 
getexample.com/api/Customer/optout/customerid
curl --request GET \
  --url http://example.com/api/Customer/optout/customerid \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Customer/optout/customerid',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Customer/optout/customerid")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Customer/optout/customerid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Customer/optout/customerid"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

customerid
int32
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

Environment

 
Suggest Edits

/api/Environment

 
getexample.com/api/Environment
curl --request GET \
  --url http://example.com/api/Environment \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Environment',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Environment")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Environment");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Environment"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

access token

Response

Success

 

Gets the balance for a given giftcard token.

Suggest Edits

/api/Giftcard/{giftcardToken}/balance

 
getexample.com/api/Giftcard/giftcardToken/balance
curl --request GET \
  --url http://example.com/api/Giftcard/giftcardToken/balance \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Giftcard/giftcardToken/balance',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Giftcard/giftcardToken/balance")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Giftcard/giftcardToken/balance");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Giftcard/giftcardToken/balance"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

giftcardToken
string
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Giftcard/{giftcardToken}

 
postexample.com/api/Giftcard/giftcardToken
curl --request POST \
  --url http://example.com/api/Giftcard/giftcardToken \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/api/Giftcard/giftcardToken',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Giftcard/giftcardToken")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Giftcard/giftcardToken");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Giftcard/giftcardToken"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

giftcardToken
string
required

Body Params

saleId
int32
amount
double
comment
string

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Login

 
postexample.com/api/Login
curl --request POST \
  --url http://example.com/api/Login
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/Login' };

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

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

url = URI("http://example.com/api/Login")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Login");

xhr.send(data);
import requests

url = "http://example.com/api/Login"

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

userName
string
password
string

Response

Success

 

Get product lists with or without stock quantities. IMPORTANT! When referring to page size, this means sizes, not product IDs.

 public static async Task<string> GetProductCount(string baseurl, string token)
  {

          var client = new HttpClient();

          var content =
              new StringContent("{}");

          client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);

          content.Headers.ContentType.MediaType = "application/json";

          var response = await client.PostAsync($"{baseurl}product/count", content);

          return await response.Content.ReadAsStringAsync();

  }

Count all available products

//Count all products 
public static async Task<string> GetProductCount(string baseurl, string token)
  {

          var client = new HttpClient();

          var content =
              new StringContent("{}");

          client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);

          content.Headers.ContentType.MediaType = "application/json";

          var response = await client.PostAsync($"{baseurl}product/count", content);

          return await response.Content.ReadAsStringAsync();

  }

Count only web available products

 public static async Task<string> GetProductCount(string baseurl, string token)
 {
         var client = new HttpClient();
         var content =
              new StringContent(JsonConvert.SerializeObject(
                  new
                 {
                      isWebAvailable = true
                  }));

         client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);
         content.Headers.ContentType.MediaType = "application/json";
         var response = await client.PostAsync($"{baseurl}product/count", content);
         return await response.Content.ReadAsStringAsync();
 }
Suggest Edits

/api/Product

 
postexample.com/api/Product
curl --request POST \
  --url http://example.com/api/Product \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Product',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Product");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

pageSize
int32
pageSkip
int32
upt
date-time
isWebAvailable
boolean
isDiscontinued
boolean
seasons
array of strings
brands
array of strings
tags
array of strings
includeEmptyGTINs
boolean
includeStockQuantity
boolean
productId
int32
identity
string
gtin
string
productIds
array of integers
identities
array of strings
gtiNs
array of strings

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Product/count

 
postexample.com/api/Product/count
curl --request POST \
  --url http://example.com/api/Product/count \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Product/count',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/count")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Product/count");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/count"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

pageSize
int32
pageSkip
int32
upt
date-time
isWebAvailable
boolean
isDiscontinued
boolean
seasons
array of strings
brands
array of strings
tags
array of strings
includeEmptyGTINs
boolean
includeStockQuantity
boolean
productId
int32
identity
string
gtin
string
productIds
array of integers
identities
array of strings
gtiNs
array of strings

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Product/productid/{id}

 
getexample.com/api/Product/productid/id
curl --request GET \
  --url http://example.com/api/Product/productid/id \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Product/productid/id',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/productid/id")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/productid/id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/productid/id"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
int32
required

Headers

Authorization
string
required

access token

Response

Success

productidinteger
namestring
numberstring
variantstring
groupNamestring
subgroupNamestring
colorstring
seasonstring
brandstring
genderstring
isDiscontinuedboolean
tagsstring
pricenumber
uptstring
descriptionstring
internalDescriptionstring
isStockProductboolean
pictureRefstring
isWebAvailableboolean
productSizesarray
imagesarray
Suggest Edits

/api/Product/gtin/{id}

 
getexample.com/api/Product/gtin/id
curl --request GET \
  --url http://example.com/api/Product/gtin/id \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Product/gtin/id',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/gtin/id")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/gtin/id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/gtin/id"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Headers

Authorization
string
required

access token

Response

Success

productidinteger
namestring
numberstring
variantstring
groupNamestring
subgroupNamestring
colorstring
seasonstring
brandstring
genderstring
isDiscontinuedboolean
tagsstring
pricenumber
uptstring
descriptionstring
internalDescriptionstring
isStockProductboolean
pictureRefstring
isWebAvailableboolean
productSizesarray
imagesarray
Suggest Edits

/api/Product/id/{id}

 
getexample.com/api/Product/id/id
curl --request GET \
  --url http://example.com/api/Product/id/id \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Product/id/id',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/id/id")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/id/id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/id/id"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Headers

Authorization
string
required

access token

Response

Success

productidinteger
namestring
numberstring
variantstring
groupNamestring
subgroupNamestring
colorstring
seasonstring
brandstring
genderstring
isDiscontinuedboolean
tagsstring
pricenumber
uptstring
descriptionstring
internalDescriptionstring
isStockProductboolean
pictureRefstring
isWebAvailableboolean
productSizesarray
imagesarray
Suggest Edits

/api/Product/seasons

 
getexample.com/api/Product/seasons
curl --request GET \
  --url http://example.com/api/Product/seasons \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Product/seasons',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/seasons")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/seasons");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/seasons"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Product/images/{id}

 
getexample.com/api/Product/images/id
curl --request GET \
  --url http://example.com/api/Product/images/id \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Product/images/id',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/images/id")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/images/id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/images/id"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
int32
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Product/brands

 
getexample.com/api/Product/brands
curl --request GET \
  --url http://example.com/api/Product/brands \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Product/brands',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/brands")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/brands");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/brands"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Product/tags

 
getexample.com/api/Product/tags
curl --request GET \
  --url http://example.com/api/Product/tags \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Product/tags',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Product/tags")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Product/tags");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Product/tags"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

ProductTransfer

 
Suggest Edits

/api/ProductTransfer

 
putexample.com/api/ProductTransfer
curl --request PUT \
  --url http://example.com/api/ProductTransfer \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/ProductTransfer',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/ProductTransfer")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://example.com/api/ProductTransfer");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/ProductTransfer"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

extRef
string
stockId
int32
storeId
int32
toStockId
int32
orderDate
date-time
expectedDeliveryDate
date-time
comment
string
insertAsRecevied
boolean
productLines
array of objects
identity
gtin
qty
cost
sgtin

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

PurchaseOrder

 
Suggest Edits

/api/PurchaseOrder

 
putexample.com/api/PurchaseOrder
curl --request PUT \
  --url http://example.com/api/PurchaseOrder \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/PurchaseOrder',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/PurchaseOrder")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://example.com/api/PurchaseOrder");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/PurchaseOrder"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

extRef
string
stockId
int32
storeId
int32
orderDate
date-time
expectedDeliveryDate
date-time
comment
string
insertAsConfirmed
boolean
orderLines
array of objects
identity
gtin
qty
cost
sgtin

Headers

Authorization
string
required

access token

Response

Success

This is for sending inn sale. The important this here is that the sum of sales lines and payment lines must be 0. If a product is discounted use the discounted price in SalesLines. The discount rate will be calculated based on the products outprice (full price).

This is a minimum sale:

 public static async Task<string> NewSale(string baseurl, string token)
  {

      var client = new HttpClient();

      var sale = new
      {
          saleGuid = Guid.NewGuid(),
          ExtRef = "MyWebshopSaleId123",
          CustomerId = 12345,
          SaleDateTime = DateTime.Now,
          SalesLines = new[]
          {
               new { identity = "021807670213", Text = "Super pair of pants 32/32", Price = 1000.00, Qty = 1, Vat = 0.25 },
               new { identity = "021740120215", Text = "Cool sweater L", Price = 750.00, Qty = 1, Vat = 0.25 }
          },
          PaymentLines = new[]
          {
              new { ExtRef = "ReferenceFromPaymentProvider", Amount = 1750.0, PaymentType = (int)PaymentTypeEnum.KlarnaKonto, CardType = (int)CardTypeEnum.None}
          }

      };

      var content =  new StringContent(JsonConvert.SerializeObject(sale));
      client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);
      content.Headers.ContentType.MediaType = "application/json";
      var response = await client.PutAsync($"{baseurl}sale", content);
      return await response.Content.ReadAsStringAsync();

  }

The enums for the payment types and card type are here

 public enum PaymentTypeEnum
  {
      Invoice = 6,
      PayEx = 7,
      Vipps = 10,
      NetAxept = 115,
      Dibs = 116,
      COD = 117,
      KlarnaFaktura = 124,
      KlarnaKonto = 125,
      Collector = 141,
      GiftCard = 5,
      BonusPoints = 128
  }



  public enum CardTypeEnum
  {

      None = 0,
      Visa = 3,
      ECMC = 4,
      Amex = 5,
      Diners = 6,
      BankAxxess = 10000
  }

If the payment is credit card, just use payment type NetAxept. And if the payment is not credit card the CartType is set to None.

Suggest Edits

/api/Sale

 
putexample.com/api/Sale
curl --request PUT \
  --url http://example.com/api/Sale \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/Sale',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Sale")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://example.com/api/Sale");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Sale"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

saleGuid
uuid
extRef
string
customerID
int32
saleDateTime
date-time
isComplete
boolean
isVoided
boolean
comment
string
salesLines
array of objects
identity
text
price
qty
stockID
vat
paymentLines
array of objects
extRef
currency
amount
paymentType
cardType
responseBody

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Sale/freight

 
getexample.com/api/Sale/freight
curl --request GET \
  --url http://example.com/api/Sale/freight \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Sale/freight',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Sale/freight")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Sale/freight");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Sale/freight"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Stock

 
postexample.com/api/Stock
curl --request POST \
  --url http://example.com/api/Stock \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Stock',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Stock")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Stock");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Stock"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

pageSize
int32
pageSkip
int32
ins
date-time
stockIds
array of integers
suppressZeroes
boolean
useGTIN
boolean

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Stock/count

 
postexample.com/api/Stock/count
curl --request POST \
  --url http://example.com/api/Stock/count \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/Stock/count',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Stock/count")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("POST", "http://example.com/api/Stock/count");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Stock/count"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

pageSize
int32
pageSkip
int32
ins
date-time
stockIds
array of integers
suppressZeroes
boolean
useGTIN
boolean

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Stock/product/{id}

 
getexample.com/api/Stock/product/id
curl --request GET \
  --url http://example.com/api/Stock/product/id \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Stock/product/id',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Stock/product/id")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Stock/product/id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Stock/product/id"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
int32
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Stock/identity/{id}

 
getexample.com/api/Stock/identity/id
curl --request GET \
  --url http://example.com/api/Stock/identity/id \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/api/Stock/identity/id',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Stock/identity/id")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Stock/identity/id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Stock/identity/id"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

id
string
required

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/Stock/list

 
getexample.com/api/Stock/list
curl --request GET \
  --url http://example.com/api/Stock/list \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/Stock/list',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/Stock/list")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/Stock/list");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/Stock/list"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

access token

Response

Success

 
Suggest Edits

/api/WebSales/OrderId

 
getexample.com/api/WebSales/OrderId
curl --request GET \
  --url http://example.com/api/WebSales/OrderId \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/WebSales/OrderId',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/WebSales/OrderId")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/WebSales/OrderId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/WebSales/OrderId"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

OrderId
string

Headers

Authorization
string
required

access token

Response

Success

Suggest Edits

/api/WebSales

 
getexample.com/api/WebSales
curl --request GET \
  --url 'http://example.com/api/WebSales?days=days' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/WebSales',
  qs: { days: 'days' },
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/WebSales?days=days")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("GET", "http://example.com/api/WebSales?days=days");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/WebSales"

querystring = {"days":"days"}

headers = {'authorization': 'Authorization'}

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

days
int32
required

Headers

Authorization
string
required

access token

Response

Success

This gets all websales for specified days back. Use Websale.Orderstatus and webSalesViewLine.PickStatus to determine whether the order lines have been picked or not.

public enum WebSaleOrderStatus
    {
        NotHandled, 
        Shipped, 
        PartlyRejected,
        Rejected
    }

public enum PickStatus
    {
        NotPicked,
        Picked,
        Rejected
    }
Suggest Edits

/api/WebSales/PickWeborder

 
putexample.com/api/WebSales/PickWeborder
curl --request PUT \
  --url http://example.com/api/WebSales/PickWeborder \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/WebSales/PickWeborder',
  headers: { authorization: 'Authorization' } };

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

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

url = URI("http://example.com/api/WebSales/PickWeborder")

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

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

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

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

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

xhr.open("PUT", "http://example.com/api/WebSales/PickWeborder");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/api/WebSales/PickWeborder"

headers = {'authorization': 'Authorization'}

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

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

saleid
int32
comment
string
status
int32
picks
array of objects
saleslineid
status
identifier
stockId

Headers

Authorization
string
required

access token

Response

Success