NAV
Shell Node Go Ruby Python

Introduction

Welcome! The ABS API enables partner integrations with Automotive Business Solutions.

You can view code examples in the dark area to the right, and you can switch the programming language of the examples with the tabs along the top.

Authentication

ABS uses standard JWT tokens for authentication.

We use the HS256 encryption format and will assign a partner id to be sent as a JWT claim. Think of the way we use JWTs as modern API keys without the security exposure of basic authentication. JWTs can be created by most web development libraries and can be tested out at sites like this one:

https://jwt.io/#debugger-io

If your systems are not equipped to handle JWT token-based authentication, please contact us to discuss simpler but less secure options.

ABS will assign each partner a client secret (a long string of random numbers) and a partner id.

Using standard web development libraries, the partner will generate a JWT token using the assigned secret with partnerid:<your partnerid> and claimdate: <current date in YYYY-MM-DD format> in the claims (a standard in JWT).

The partner will call the API with a standard HTTP POST that has the following Headers set:

header 'Authorization: Bearer <JWT Token>'
header 'Content-Type: application/json'

If anything goes wrong with the Authentication the API will return 401 (Unauthorized)

To obtain your client secret and partner ID, please reach out to us at engineering@abswarranty.net.

To authorize, use this code:

package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "api_endpoint_here"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "Bearer {JWT}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := ioutil.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
# With shell, you can just pass the correct header with each request
curl "api_endpoint_here"
  -H "Authorization: Bearer {JWT}"
require "uri"
require "net/http"

url = URI("api_endpoint_here")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer {JWT}"

response = http.request(request)
puts response.read_body
import requests

url = "api_endpoint_here"

payload={}
headers = {
  'Authorization': 'Bearer {JWT}'
}

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

print(response.text)
var axios = require('axios');

var config = {
  method: 'get',
  url: 'api_endpoint_here',
  headers: { 
    Authorization: `Bearer ${JWT}`
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});

Make sure to replace {JWT} with your JWT token.

Sending Data

The body of the post will be a JSON representation of the object being passed (Registrations, Claims, Sales or Cancellations) and the fields listed below in the data dictionary.

Numbers should be passed as true numbers to make validation simpler, strings will be quoted as standard JSON.

Return code will be standard HTTP status codes with more information about each post as JSON in the body

Return Codes:

TPP

The TPP API is used to send ABS registrations, cancellations, claims, and sales data.

The base URL for this API is https://data.absintegrations.com. There will be a version number, endpoint and company name added to the end of the URL for each partner so your API URL will look like https://data.absintegrations.com/v2/partners/tirecompany.

The API uses a very simple REST protocol that, once authorized, just takes a FORM POST with some authorization info in the headers and a JSON representation of the data being sent in the body of the POST.

Record Types

The API accepts four main record types, they may not all be applicable to your use case.

Some key logic to understand:

Below is a list of our standard tables and their fields. If your system can’t generate each of these or if your system has key fields not listed, please contact ABS to discuss your specifics.

The Field Name listed below will be the JSON label for the application/json body of the POST to the API.

Registrations

Field Name Field Desc Data Type Required Notes
OrgID Organization ID string (50) N Optional field for grouping things like ownership groups. Will be blank if not passed in
ShopID Dealer/Store/Shop ID string(25) Y Shop where the tires were sold
InvoiceNumber Invoice Number string(50) Y Invoice for the registration
PlanEnrollDate Plan Enroll Date datetime Y Date of enrollment
EmployeeID Employee ID string(50) Y To track individual responsible for TPP sale
CustomerID Customer ID String(50) Y Enables data to be filtered by individual customer (could be customer name or customer id number)
VehicleYear Vehicle Year string(25) Four-digit year
VehicleMake Vehicle Make string(25)
VehicleModel Vehicle Model string(25)
VIN VIN string(50) If available
CurrentMileage Current Vehicle Mileage int Mileage at time of TPP registration/sale
TiresCovered Count of Tires Covered int Y How many tires are covered on this registration
TPPPrice TPP Price money Y TPP Price Per Tire
TireBrand Tire Make/Brand string(25) Y For all tire sales with an attached TPP
TireModel Tire Model string(25)
TireSize Tire Size string(25) Y
TirePrice Tire Retail Price money Y Tire Retail Price Per Tire
TireCost Tire Wholesale Price money Y Tire Wholesale Cost Per Tire
TireDOT1 TireDOT1 string(25) Y For all tire sales with an attached TPP / if available
TireDOT2 TireDOT2 string(25)
TireDOT3 TireDOT3 string(25)
TireDOT4 TireDOT4 string(25)
TireDOT5 TireDOT5 string(25)
TireDOT6 TireDOT6 string(25)
CommercialVehicle Commercial Vehicle string(5) Yes or No (Default is No)

Claims

Field Name Field Desc Data Type Required Notes
OrgID Organization ID string (50) N Optional field for grouping by things like ownership groups. Will be blank if not passed in
ShopID Dealer/Store/Shop ID string(25) Y Shop where the registration was sold
InvoiceNumber Repair Invoice Number string(25) Y Invoice Number for the original registration sale
ClaimDate Claim Date datetime Y Date of claim
RepairShopID Original Store / ShopID string(25) Y Shop ID where the repair was performed
RepairInvoiceNumber Original Invoice Number string(50) Y Invoice from the repair work
VIN VIN string(50) If available
VehicleMileage Vehicle Mileage at Time of Claim int Mileage at the time of repair
TireClaimCount Count of Tires in Claim int Y How many tires were repaired
CreditAmount Amount Credited to Customer (Total) money Y Discount amount * quantity
CostPerUnit Amount the Claim Cost Per Unit money Y Replacement cost per tire at time of repair
TireLocation1 Location of tire 1 on vehicle string(200) Ex. “front passenger” or “right front”
TireLocation2 Location of tire 2 on vehicle string(200)
TireLocation3 Location of tire 3 on vehicle string(200)
TireLocation4 Location of tire 4 on vehicle string(200)
TireLocation5 Location of tire 5 on vehicle string(200)
TireLocation6 Location of tire 6 on vehicle string(200)
ServiceDescription Service Classification / Description string(200) i.e., “sidewall” or “screw in tread” - incorporate dropdown into POS screen?
TireBrand Replacement Tire Make/Brand string(25) Y
TireModel Replacement Tire Model string(25)
TireSize Replacement Tire Size string(25) Y
TireCost Replacement Tire Price money Y

Sales

Field Name Field Desc Data Type Required Notes
OrgID Organization ID string (50) N Optional field for grouping by things like ownership groups. Will be blank if not passed in
ShopID Dealer/Store/Shop ID string(25) Y Shop that made the sale
InvoiceNumber Sale Invoice Number string(25) Y Invoice number for the sale
SaleDate Date Sold datetime Y Date of the sale
TireCount Count of Tires Covered int Y Number of tires sold
TireBrand Tire Make/Brand string(25) Y for all tire sales with and without an attached TPP
TireModel Tire Model string(25) Y
TireSize Tire Size string(25) Y
TirePrice Tire Retail Price money Y what customer pays
TireCost Tire Wholesale Price money Y what shop pays

Cancellations

Field Name Field Desc Data Type Required Notes
OrgID Organization ID string (50) N Optional field for grouping. For example ownership group. Blank if not passed in
ShopID Dealer/Store/Shop ID string(25) Y Shop ID from original sale and registration
InvoiceNumber Sale Invoice Number string(25) Y Invoice from the original sale and registration
CancelShopID Dealer/Store/Shop ID string(25) Y Shop ID where the tire registrations were cancelled
CancelInvoiceNumber Sale Invoice Number string(25) Y Invoice from the the shop where tire registrations were cancelled
TireCancelCount Count of Tires Cancelled int Y How many tires were cancelled
CancelDate Date Cancelled datetime Y Date of the cancellation

Notes on data types

Numeric Data: ABS can usually convert from string representations to appropriate numbers.

Date Time: All dates should be ISO 8601 format YYYYMMDDTHH:MM:SS in UTC time zone preferably or with designated offset from UTC. If your system is always synced to a specific time zone let us know and we can create a custom import based on a static time zone.

Money: Money / dollar amounts should be numeric with 2 decimal point precision or a matching string representation.

If any of data fields are required and empty or malformed, the API will return a HTTP status 400 “Bad Request”. It should be easy to determine which fields are not present in the JSON data or badly formed, feel free to contact us if seemingly valid data is being rejected.

Registrations

Sale of a tire that is registered with a warranty.

Notes:

Registrations [GET]

Use query parameters to search and retrieve registrations created with us

curl --location --request GET https://data.absintegrations.com/v2/partners/{company_name}?rec=registrations&partnerid={partner_id}&shopid=12345&invoicenumber=12345 \
--header 'content-type: application/json' \
--header 'Authorization: Bearer {JWT}'
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}?rec=registrations&partnerid={partner_id}&shopid=12345&invoicenumber=12345")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer {JWT}"

response = https.request(request)
puts response.read_body
var axios = require('axios');

var config = {
  method: 'get',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}?rec=registrations&partnerid={partner_id}&shopid=12345&invoicenumber=12345',
  headers: { 
    'Authorization': 'Bearer {JWT}'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}?rec=registrations&partnerid={partner_id}&shopid=12345&invoicenumber=12345"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}
import requests

url = "https://data.absintegrations.com/v2/partners/{company_name}?rec=registrations&partnerid={partner_id}&shopid=12345&invoicenumber=12345"

payload = {}
headers = {
  'Authorization': 'Bearer {JWT}'
}

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

print(response.text.encode('utf8'))

The above command returns JSON structured like this:

{
    "PartnerID": 1001,
    "OrgID": "",
    "ShopID": "005108",
    "InvoiceNumber": "104252",
    "PlanEnrollDate": "2018-12-04T00:00:00Z",
    "EmployeeID": "JP006",
    "CustomerID": "5108-491514",
    "VehicleYear": "08",
    "VehicleMake": "LEXUS",
    "VehicleModel": "IS 250",
    "VIN": "JTHBK262X82078324",
    "CurrentMileage": 175920,
    "TiresCovered": 2,
    "TPPPrice": 322.18,
    "TireBrand": "SUM",
    "TireModel": "225/40R18/XL 92W SUMITOMO HTR A/S P02",
    "TireSize": "2254018",
    "TirePrice": 104.98,
    "TireCost": 74.01,
    "TireDOT1": "",
    "TireDOT2": "",
    "TireDOT3": "",
    "TireDOT4": "",
    "TireDOT5": "",
    "TireDOT6": "",
    "CommercialVehicle": "false"
}

Registrations [POST]

Use this endpoint to create one or more new registrations with ABS

curl --request POST \
--url https://data.absintegrations.com/v2/partners/{company_name} \
--header 'authorization: Bearer eyJhb...SQj6A' \
--header 'content-type: application/json' \
--data {
"Registrations": [
{
"ShopID": "005308",
"InvoiceNumber": "1044273",
"PlanEnrollDate": "2018-12-04",
"EmployeeID": "JP0078",
"CustomerID": "5108-460340",
"VehicleYear": "08",
"VehicleMake": "GMC TRUCK",
"VehicleModel": "SIERRA 1500 PICKUP",
"VIN": "2GTEC19C481101249",
"CurrentMileage": "187437",
"TiresCovered": 4,
"TPPPrice": 995.68,
"TireBrand": "NIT",
"TireModel": "P265/65R18 112T NITTO CROSSTEK 2",
"TireSize": "2656518",
"TirePrice": 188.99,
"TireCost": 105.98,
"TireDOT1": "DOT 73C2 KLH0913",
"CommercialVehicle": "false"
}]}
var axios = require('axios');
var data = {
    "Registrations": [
        {
            "ShopID": "005308",
            "InvoiceNumber": "1044273",
            "PlanEnrollDate": "2018-12-04",
            "EmployeeID": "JP0078",
            "CustomerID": "5108-460340",
            "VehicleYear": "08",
            "VehicleMake": "GMC TRUCK",
            "VehicleModel": "SIERRA 1500 PICKUP",
            "VIN": "2GTEC19C481101249",
            "CurrentMileage": "187437",
            "TiresCovered": 4,
            "TPPPrice": 995.68,
            "TireBrand": "NIT",
            "TireModel": "P265/65R18 112T NITTO CROSSTEK 2",
            "TireSize": "2656518",
            "TirePrice": 188.99,
            "TireCost": 105.98,
            "TireDOT1": "DOT 73C2 KLH0913",
            "CommercialVehicle": "false"
        }
    ]
};

var config = {
  method: 'post',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}',
  headers: { 
    'Authorization': 'Bearer {JWT}', 
    'Content-Type': 'application/json'
  },
  data : data
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

body = {
    "Registrations": [
        {
            "ShopID": "005308",
            "InvoiceNumber": "1044273",
            "PlanEnrollDate": "2018-12-04",
            "EmployeeID": "JP0078",
            "CustomerID": "5108-460340",
            "VehicleYear": "08",
            "VehicleMake": "GMC TRUCK",
            "VehicleModel": "SIERRA 1500 PICKUP",
            "VIN": "2GTEC19C481101249",
            "CurrentMileage": "187437",
            "TiresCovered": 4,
            "TPPPrice": 995.68,
            "TireBrand": "NIT",
            "TireModel": "P265/65R18 112T NITTO CROSSTEK 2",
            "TireSize": "2656518",
            "TirePrice": 188.99,
            "TireCost": 105.98,
            "TireDOT1": "DOT 73C2 KLH0913",
            "CommercialVehicle": "false"
        }
    ]
}

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer {JWT}"
request["Content-Type"] = "application/json"
request.body = body

response = https.request(request)
puts response.read_body
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}"
  method := "POST"

  payload := strings.NewReader("{
\n    \"Registrations\": [
\n        {
\n            \"ShopID\": \"005308\",
\n            \"InvoiceNumber\": \"1044273\",
\n            \"PlanEnrollDate\": \"2018-12-04\",
\n            \"EmployeeID\": \"JP0078\",
\n            \"CustomerID\": \"5108-460340\",
\n            \"VehicleYear\": \"08\",
\n            \"VehicleMake\": \"GMC TRUCK\",
\n            \"VehicleModel\": \"SIERRA 1500 PICKUP\",
\n            \"VIN\": \"2GTEC19C481101249\",
\n            \"CurrentMileage\": \"187437\",
\n            \"TiresCovered\": 4,
\n            \"TPPPrice\": 995.68,
\n            \"TireBrand\": \"NIT\",
\n            \"TireModel\": \"P265/65R18 112T NITTO CROSSTEK 2\",
\n            \"TireSize\": \"2656518\",
\n            \"TirePrice\": 188.99,
\n            \"TireCost\": 105.98,
\n            \"TireDOT1\": \"DOT 73C2 KLH0913\",
\n            \"CommercialVehicle\": \"false\"
\n        }
\n    ]
\n}")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}
import requests
import json

url = "https://data.absintegrations.com/v2/partners/{company_name}"

payload = {
    "Registrations": [
        {
            "ShopID": "005308",
            "InvoiceNumber": "1044273",
            "PlanEnrollDate": "2018-12-04",
            "EmployeeID": "JP0078",
            "CustomerID": "5108-460340",
            "VehicleYear": "08",
            "VehicleMake": "GMC TRUCK",
            "VehicleModel": "SIERRA 1500 PICKUP",
            "VIN": "2GTEC19C481101249",
            "CurrentMileage": "187437",
            "TiresCovered": 4,
            "TPPPrice": 995.68,
            "TireBrand": "NIT",
            "TireModel": "P265/65R18 112T NITTO CROSSTEK 2",
            "TireSize": "2656518",
            "TirePrice": 188.99,
            "TireCost": 105.98,
            "TireDOT1": "DOT 73C2 KLH0913",
            "CommercialVehicle": "false"
        }
    ]
}

headers = {
  'Authorization': 'Bearer {JWT}',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data = json.dumps(payload))

print(response.text.encode('utf8'))

Registration Status

Each registration will have a status associated with it.

Possible values for WarrantyStatus

  1. Registration is Active
  2. Registration is Cancelled
  3. No Tires left on Registration
  4. Registration is Expired

Notes:

Registration Status [GET]

This is a special call to check on the status of a registration, call it just like GET Registration but it also returns the current status and number of tires left on the registration.

curl --location --request GET https://data.absintegrations.com/v2/partners/{company_name}?rec=registrationstatus&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345 \
--header 'content-type: application/json' \
--header 'Authorization: Bearer {JWT}'
import requests

url = "https://data.absintegrations.com/v2/partners/{company_name}?rec=registrationstatus&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345"

payload = {}
headers = {
  'Authorization': 'Bearer {JWT}'
}

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

print(response.text.encode('utf8'))
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}?rec=registrationstatus&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer {JWT}"

response = https.request(request)
puts response.read_body
var axios = require('axios');

var config = {
  method: 'get',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}?rec=registrationstatus&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345',
  headers: { 
    'Authorization': 'Bearer {JWT}'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}?rec=registrationstatus&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}

The above retursn JSON structured like this

{
    "RegistrationID": 70,
    "PartnerID": 1001,
    "OrgID": "",
    "ShopID": "005108",
    "InvoiceNumber": "104252",
    "PlanEnrollDate": "2018-12-04T00:00:00Z",
    "CreatedDate": "2018-11-04T00:00:00Z",
    "TiresCovered": 2,
    "TireClaimCount": 0,
    "TireCancelCount": 0,
    "TiresLeft": 2,
    "WarrantyStatus": 1,
    "CancelDate": ,
    "ExpireDate": ,
    "StatusDate": ,
    "Message": "Registration is Active"
}

Claims

Warranty claim made on a registered sale.

Possible values for ServiceType

  1. REPLACE - tire was replaced
  2. REPAIR - tire went through a repair

Notes:

Claims [GET]

Use this endpoint to get one or more claims

curl --location --request GET https://data.absintegrations.com/v2/partners/{company_name}?rec=claims&partnerid={partnerid}&shopid=12345&invoicenumber=12345 \
--header 'content-type: application/json' \
--header 'Authorization: Bearer {JWT}'
var axios = require('axios');

var config = {
  method: 'get',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}?rec=claims&partnerid={partnerid}&shopid=12345&invoicenumber=12345',
  headers: { 
    'Authorization': 'Bearer {JWT}'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}?rec=claims&partnerid={partnerid}&shopid=12345&invoicenumber=12345"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}
import requests

url = "https://data.absintegrations.com/v2/partners/{company_name}?rec=claims&partnerid={partnerid}&shopid=12345&invoicenumber=12345"

payload = {}
headers = {
  'Authorization': 'Bearer {JWT}'
}

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

print(response.text.encode('utf8'))
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}?rec=claims&partnerid={partnerid}&shopid=12345&invoicenumber=12345")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer {JWT}"

response = https.request(request)
puts response.read_body

The above returns JSON structured like this

{
    "PartnerID": 1001,
    "OrgID": "",
    "ShopID": "005108",
    "InvoiceNumber": "104155",
    "ClaimDate": "2020-01-27T00:00:00Z",
    "RepairShopID": "005108",
    "RepairInvoiceNumber": "104273",
    "VIN": "",
    "VehicleMileage": 96192,
    "TireClaimCount": 4,
    "CreditAmount": 64.04,
    "CostPerUnit": 60,
    "ServiceType": "REPLACE",
    "ServiceDescription": "",
    "TireLocation1": "",
    "TireLocation2": "",
    "TireLocation3": "",
    "TireLocation4": "",
    "TireLocation5": "",
    "TireLocation6": "",
    "TireBrand": "SUM",
    "TireModel": "235/60R18/XL 107V SUMITOMO HTR A/S P02 BLK",
    "TireSize": "2356018",
    "TirePrice": 0,
    "TireCost": 58.94
}

Claims [POST]

Use this endpoint to create one or more new claims with ABS

curl --location --request POST 'https://data.absintegrations.com/v2/partners/{company_name}' \
--header 'Authorization: Bearer {JWT}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "Claims": [
        {
            "ShopID": "0056678",
            "InvoiceNumber": "35554367",
            "ClaimDate": "2020-01-27",
            "ShopID": "0056698",
            "InvoiceNumber": "9994498",
            "VehicleMileage": 96192,
            "TireClaimCount": 4,
            "CreditAmount": 64.04,
            "CostPerUnit": 60.00,
            "ServiceType": "REPLACE",
            "ServiceDescription": "FLAT REPAIR PASSENGER REAR",
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TireCost": 58.00
        }
    ]
}'
var axios = require('axios');
var data = {
    "Claims": [
        {
            "ShopID": "0056678",
            "InvoiceNumber": "35554367",
            "ClaimDate": "2020-01-27",
            "ShopID": "0056698",
            "InvoiceNumber": "9994498",
            "VehicleMileage": 96192,
            "TireClaimCount": 4,
            "CreditAmount": 64.04,
            "CostPerUnit": 60.00,
            "ServiceType": "REPLACE",
            "ServiceDescription": "FLAT REPAIR PASSENGER REAR",
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TireCost": 58.00
        }
    ]
}

var config = {
  method: 'post',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}',
  headers: { 
    'Authorization': 'Bearer {JWT}', 
    'Content-Type': 'application/json'
  },
  data : data
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests
import json

url = "https://data.absintegrations.com/v2/partners/{company_name}"

payload = {
    "Claims": [
        {
            "ShopID": "0056678",
            "InvoiceNumber": "35554367",
            "ClaimDate": "2020-01-27",
            "ShopID": "0056698",
            "InvoiceNumber": "9994498",
            "VehicleMileage": 96192,
            "TireClaimCount": 4,
            "CreditAmount": 64.04,
            "CostPerUnit": 60.00,
            "ServiceType": "REPLACE",
            "ServiceDescription": "FLAT REPAIR PASSENGER REAR",
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TireCost": 58.00
        }
    ]
}

headers = {
  'Authorization': 'Bearer {JWT}',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data = json.dumps(payload))

print(response.text.encode('utf8'))
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer {JWT}"
request["Content-Type"] = "application/json"
request.body = {
    "Claims": [
        {
            "ShopID": "0056678",
            "InvoiceNumber": "35554367",
            "ClaimDate": "2020-01-27",
            "ShopID": "0056698",
            "InvoiceNumber": "9994498",
            "VehicleMileage": 96192,
            "TireClaimCount": 4,
            "CreditAmount": 64.04,
            "CostPerUnit": 60.00,
            "ServiceType": "REPLACE",
            "ServiceDescription": "FLAT REPAIR PASSENGER REAR",
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TireCost": 58.00
        }
    ]
}

response = https.request(request)
puts response.read_body
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}"
  method := "POST"

  payload := strings.NewReader("{
\n    \"Claims\": [
\n        {
\n            \"ShopID\": \"0056678\",
\n            \"InvoiceNumber\": \"35554367\",
\n            \"ClaimDate\": \"2020-01-27\",
\n            \"ShopID\": \"0056698\",
\n            \"InvoiceNumber\": \"9994498\",
\n            \"VehicleMileage\": 96192,
\n            \"TireClaimCount\": 4,
\n            \"CreditAmount\": 64.04,
\n            \"CostPerUnit\": 60.00,
\n            \"ServiceType\": \"REPLACE\",
\n            \"ServiceDescription\": \"FLAT REPAIR PASSENGER REAR\",
\n            \"TireBrand\": \"SUM\",
\n            \"TireModel\": \"235/60R18/XL 107V HTR A/S P02 BLK\",
\n            \"TireSize\": \"2356018\",
\n            \"TireCost\": 58.00
\n        }
\n    ]
\n}")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}

Sales

Sales made on tires including registered and unregistered sales.

Sales [GET]

Use this endpoint to retrieve one or more Sales

curl --location --request GET https://data.absintegrations.com/v2/partners/{company_name}?rec=sales&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345 \
--header 'content-type: application/json' \
--header 'Authorization: Bearer {JWT}'
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}?rec=sales&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer {JWT}"

response = https.request(request)
puts response.read_body
var axios = require('axios');

var config = {
  method: 'get',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}?rec=sales&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345',
  headers: { 
    'Authorization': 'Bearer {JWT}'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests

url = "https://data.absintegrations.com/v2/partners/{company_name}?rec=sales&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345"

payload = {}
headers = {
  'Authorization': 'Bearer {JWT}'
}

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

print(response.text.encode('utf8'))
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}?rec=sales&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}

The above returns JSON structured like this

{
    "PartnerID": 1001,
    "OrgID": ,
    "ShopID": "005058",
    "InvoiceNumber": "354404",
    "SaleDate": "2020-01-27T00:00:00Z",
    "TireCount": 1,
    "TireBrand": ,
    "TireModel": ,
    "TireSize": ,
    "TirePrice": 99.99,
    "TireCost": 78.16
}

Sales [POST]

Use this endpoint to create one or more new sales with ABS

curl --request POST \
--url https://data.absintegrations.com/v2/partners/{company_name} \
--header 'authorization: Bearer eyJhb...SQj6A' \
--header 'content-type: application/json' \
--data {
"Sales": [
{
"ShopID": "005054568",
"InvoiceNumber": "354365667",
"SaleDate": "2020-01-27",
"TireCount": 4,
"TireBrand": "SUM",
"TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
"TireSize": "2356018",
"TirePrice": 225.09,
"TireCost": 195.09
}]}
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}"
  method := "POST"

  payload := strings.NewReader("{
\n    \"Sales\": [
\n        {
\n            \"ShopID\": \"005054568\",
\n            \"InvoiceNumber\": \"354365667\",
\n            \"SaleDate\": \"2020-01-27\",
\n            \"TireCount\": 4,
\n            \"TireBrand\": \"SUM\",
\n            \"TireModel\": \"235/60R18/XL 107V HTR A/S P02 BLK\",
\n            \"TireSize\": \"2356018\",
\n            \"TirePrice\": 225.09,
\n            \"TireCost\": 195.09
\n        }
\n    ]
\n}")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}
var axios = require('axios');
var data = {
    "Sales": [
        {
            "ShopID": "005054568",
            "InvoiceNumber": "354365667",
            "SaleDate": "2020-01-27",
            "TireCount": 4,
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TirePrice": 225.09,
            "TireCost": 195.09
        }
    ]
}

var config = {
  method: 'post',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}',
  headers: { 
    'Authorization': 'Bearer {JWT}', 
    'Content-Type': 'application/json'
  },
  data : data
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
import requests
import json

url = "https://data.absintegrations.com/v2/partners/{company_name}"

payload = {
    "Sales": [
        {
            "ShopID": "005054568",
            "InvoiceNumber": "354365667",
            "SaleDate": "2020-01-27",
            "TireCount": 4,
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TirePrice": 225.09,
            "TireCost": 195.09
        }
    ]
}

headers = {
  'Authorization': 'Bearer {JWT}',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data = json.dumps(payload))

print(response.text.encode('utf8'))
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer {JWT}"
request["Content-Type"] = "application/json"
request.body = {
    "Sales": [
        {
            "ShopID": "005054568",
            "InvoiceNumber": "354365667",
            "SaleDate": "2020-01-27",
            "TireCount": 4,
            "TireBrand": "SUM",
            "TireModel": "235/60R18/XL 107V HTR A/S P02 BLK",
            "TireSize": "2356018",
            "TirePrice": 225.09,
            "TireCost": 195.09
        }
    ]
}

response = https.request(request)
puts response.read_body

Cancellations

Cancellation of an existing warranty.

Cancellations [GET]

Use this endpoint to retrieve one or more cancellations

curl --location --request GET https://data.absintegrations.com/v2/partners/{company_name}?rec=cancellations&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345 \
--header 'content-type: application/json' \
--header 'Authorization: Bearer {JWT}'
package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}?rec=cancellations&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}
var axios = require('axios');

var config = {
  method: 'get',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}?rec=cancellations&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345',
  headers: { 
    'Authorization': 'Bearer {JWT}'
  }
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}?rec=cancellations&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer {JWT}"

response = https.request(request)
puts response.read_body
import requests

url = "https://data.absintegrations.com/v2/partners/{company_name}?rec=cancellations&partnerid={partnerid}&ShopID=12345&InvoiceNumber=12345"

payload = {}
headers = {
  'Authorization': 'Bearer {JWT}'
}

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

print(response.text.encode('utf8'))

The above returns JSON structured like this

{
    "PartnerID": 1001,
    "OrgID": "",
    "ShopID": "005108",
    "InvoiceNumber": "104283",
    "CancelShopID": "005108",
    "CancelInvoiceNumber": "104283",
    "CancelDate": "2020-01-27T00:00:00Z"
}

Cancellations [POST]

Use this endpoint to make one or more cancellation with ABS

curl --request POST \
--url https://data.absintegrations.com/v2/partners/{company_name} \
--header 'authorization: Bearer eyJhb...SQj6A' \
--header 'content-type: application/json' \
--data {
"Cancellations": [
{
"ShopID": "005054568",
"InvoiceNumber": "354365667",
"CancelShopID": "005054568",
"CancelInvoiceNumber": "365365167",
"TireCancelCount": "1",
"CancelDate": "2020-01-27"
}]}
var axios = require('axios');
var data = {
    "Cancellations": [
        {
            "ShopID": "005054568",
            "InvoiceNumber": "354365667",
            "CancelShopID": "005054568",
            "CancelInvoiceNumber": "365365167",
            "TireCancelCount": "1",
            "CancelDate": "2020-01-27"
        }
    ]
}

var config = {
  method: 'post',
  url: 'https://data.absintegrations.com/v2/partners/{company_name}',
  headers: { 
    'Authorization': 'Bearer {JWT}', 
    'Content-Type': 'application/json'
  },
  data : data
};

axios(config)
.then(function (response) {
  console.log(JSON.stringify(response.data));
})
.catch(function (error) {
  console.log(error);
});
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://data.absintegrations.com/v2/partners/{company_name}"
  method := "POST"

  payload := strings.NewReader("{
\n    \"Cancellations\": [
\n        {
\n            \"ShopID\": \"005054568\",
\n            \"InvoiceNumber\": \"354365667\",
\n            \"CancelShopID\": \"005054568\",
\n            \"CancelInvoiceNumber\": \"365365167\",
\n            \"TireCancelCount\": \"1\",
\n            \"CancelDate\": \"2020-01-27\"
\n        }
\n    ]
\n}")

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Authorization", "Bearer {JWT}")
  req.Header.Add("Content-Type", "application/json")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}
import requests
import json

url = "https://data.absintegrations.com/v2/partners/{company_name}"

payload = {
    "Cancellations": [
        {
            "ShopID": "005054568",
            "InvoiceNumber": "354365667",
            "CancelShopID": "005054568",
            "CancelInvoiceNumber": "365365167",
            "TireCancelCount": "1",
            "CancelDate": "2020-01-27"
        }
    ]
}

headers = {
  'Authorization': 'Bearer {JWT}',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data = json.dumps(payload))

print(response.text.encode('utf8'))
require "uri"
require "net/http"

url = URI("https://data.absintegrations.com/v2/partners/{company_name}")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer {JWT}"
request["Content-Type"] = "application/json"
request.body = {
    "Cancellations": [
        {
            "ShopID": "005054568",
            "InvoiceNumber": "354365667",
            "CancelShopID": "005054568",
            "CancelInvoiceNumber": "365365167",
            "TireCancelCount": "1",
            "CancelDate": "2020-01-27"
        }
    ]
}

response = https.request(request)
puts response.read_body

Testing

While testing and debugging you can read and write from testing tables rather than the production ones. This will keep testing data nicely segregated. All you need to do is POST to partners/{mycompany}_test rather than partners/{mycompany} the url like this:

https://data.absintegrations.com/v2/partners/tirecompany_test

Errors

The ABS API uses the following error codes:

Error Code Meaning
400 Bad Request – Your have sent a bad request
401 Unauthorized – Your API key is wrong
403 Forbidden – Your API key is correct, but you do not have permission to make this request
404 Not Found – The API could not be found
405 Method Not Allowed – You tried to access an API with an invalid method
422 Unprocessable Entity – The request was formatted correctly, but could not be processed
429 Too Many Requests – You’re making too many API requests
500 Internal Server Error – We had a problem with our server. Try again later, or contact us
503 Service Unavailable – We’re temporarially offline for maintanance. Please try again later