Authentication example

/**
 * NodeJS
 */
var authHeader = new Buffer(`${clientId}:${clientSecret}`).toString('base64');

require('request')({
  method: 'POST',
  uri: 'https://developers.knowify.com/oauth/token',
  form: {
    'grant_type': 'password',
    'username': username,
    'password': password
  },
  headers: {
    'Authorization': `Basic ${authHeader}`,
    'Content-Type': 'application/x-www-form-urlencoded'
  }
}, function (err, response, body) {
  expect(body.access_token).to.be.a.string;  // "2YotnFZFEjr1zCsicMWpAA"
  expect(body.token_type).to.be.a.string;    // "bearer"
  expect(body.expires_in).to.be.a.number;    // 3600
  expect(body.refresh_token).to.be.a.string; // "tGzv3JOkF0XG5Qx2TlKWIA"
});



/**
 * Browser
 */
var authHeader = btoa(`${clientId}:${clientSecret}`);

// build the body with URLSearchParams
var params = new URLSearchParams();
params.set('grant_type', 'password');
params.set('username', username);
params.set('password', password);

// alternatively, just build a search param string with encodeURIComponent
// var params = `grant_type=password&username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}`;

fetch('https://developers.knowify.com/oauth/token', {
  method: 'POST',
  body: params.toString(),
  headers: new Headers({
    'Authorization': `Basic ${authHeader}`,
    'Content-Type': 'application/x-www-form-urlencoded'
  })
}).then(function (response) {
  return response.json();
}).then(function (body) {
  expect(body.access_token).to.be.a.string;  // "2YotnFZFEjr1zCsicMWpAA"
  expect(body.token_type).to.be.a.string;    // "bearer"
  expect(body.expires_in).to.be.a.number;    // 3600
  expect(body.refresh_token).to.be.a.string; // "tGzv3JOkF0XG5Qx2TlKWIA"
});

Parsed geoJSON example

{
  "type":"Feature",
  "geometry":{
    "type":"Point",
    "coordinates":[40.722337,-73.994885]
  },
  "properties":{
    "timestamp":"2016-02-26T20:45:49.467Z",
    "address_components":{
      "Address1":"228 Mott Street",
      "Address2":null,
      "City":"New York",
      "StateProvince":"New York",
      "Zip":"10012",
      "Country":"US"
    },
    "formatted_address":"228 Mott Street, New York, New York, US 10012",
    "location_label":"Service Ticket #000001"
  }
}

Example request/response

require('request')({
  method: 'POST',
  uri: 'https://developers.knowify.com/api/v1/clients',
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    ClientName: 'New Client Name',
    ContactName: 'John Doe'
  })
}, function (err, response, body) {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Client created successfully'
});

Example request/response

require('request')({
  method: 'GET',
  uri: `https://developers.knowify.com/api/v1/${dataTypeUrl}`,
  headers: { Authorization: `Bearer ${accessToken}` }
}, function (err, response, body) {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all records of type `dataType`*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

link object reference

{
  "first": "url/to/first/page",
  "last": "url/to/last/page",
  "next": "url/to/next/page",
  "prev": "url/to/previous/page"
}

Example request/response

require('request')({
  method: 'PUT',
  uri: `https://developers.knowify.com/api/v1/clients/${clientId}`,
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    ClientName: 'Updated Client Name',
    ContactName: 'Jane Doe'
  })
}, function (err, response, body) {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Client updated successfully'
});

Example request/response

require('request')({
  method: 'DELETE',
  uri: `https://developers.knowify.com/api/v1/${dataType}/${id}`,
  headers: { Authorization: `Bearer ${accessToken}` }
}, function (err, response, body) {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Client removed successfully'
});

Fetch All Bills

Fetch All Bills with options

Fetch Bill by Id

Fetch Bill by Id with options

Fetch Bills since date

Fetch Bills since date with options

fetch('https://developers.knowify.com/api/v1/bills', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Bills*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Bill

Example request/response

let dto = {
  "FieldName": "Description"
}

fetch('https://developers.knowify.com/api/v1/bills', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Bill created successfully'
});

Update Bill by Id

Example request/response

let dto = {
  "FieldName": "Description"
}

fetch(`https://developers.knowify.com/api/v1/bills/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Bill updated successfully'
});

Delete Bill

fetch(`https://developers.knowify.com/api/v1/bills/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Bill removed successfully'
});

Fetch All Clients

Fetch All Clients with options

Fetch Client by Id

Fetch Client by Id with options

Fetch Clients since date

Fetch Clients since date with options

fetch('https://developers.knowify.com/api/v1/clients', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Clients*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Client

Example request/response

let dto = {
  "ClientName": "New Client Name"
}

fetch('https://developers.knowify.com/api/v1/clients', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Client created successfully'
});

Create Client

Example request/response

let dto = {
  "ClientName": "New Client Name"
}

fetch('https://developers.knowify.com/api/v1/clients', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Client created successfully'
});

Update Client by Id

Example request/response

let dto = {
  "Address1": "228 Market Street",
  "City": "Philadelphia",
  "Country": "US",
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "StateProvince": "Pennsylvania",
  "Zip": "19106"
}

fetch(`https://developers.knowify.com/api/v1/clients/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Client updated successfully'
});

Update Client by Id

Example request/response

let dto = {
  "ContactName": "Jane Doe",
  "Phone": "16177850630",
  "Email": "jane.doe@company.com",
  "Website": "http://www.example.com"
}

fetch(`https://developers.knowify.com/api/v1/clients/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Client updated successfully'
});

Delete Client

fetch(`https://developers.knowify.com/api/v1/clients/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Client removed successfully'
});

Fetch All Departments

Fetch All Departments with options

Fetch Department by Id

Fetch Department by Id with options

Fetch Departments since date

Fetch Departments since date with options

fetch('https://developers.knowify.com/api/v1/departments', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Departments*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Department

Example request/response

let dto = {
  "DepartmentName": "Engineering Department"
}

fetch('https://developers.knowify.com/api/v1/departments', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Department created successfully'
});

Update Department by Id

Example request/response

let dto = {
  "DepartmentName": "Engineering Department"
}

fetch(`https://developers.knowify.com/api/v1/departments/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Department updated successfully'
});

Delete Department

fetch(`https://developers.knowify.com/api/v1/departments/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Department removed successfully'
});

Fetch All AIAInvoices

Fetch All AIAInvoices with options

Fetch Aiainvoice by Id

Fetch Aiainvoice by Id with options

Fetch AIAInvoices since date

Fetch AIAInvoices since date with options

fetch('https://developers.knowify.com/api/v1/invoices', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Invoices*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Fetch All Items

Fetch All Items with options

Fetch Item by Id

Fetch Item by Id with options

Fetch Items since date

Fetch Items since date with options

fetch('https://developers.knowify.com/api/v1/items', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Items*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Item

Example request/response

let dto = {
  "Name": "Example Name",
  "Price": "10.00",
  "Cost": "5.00"
}

fetch('https://developers.knowify.com/api/v1/items', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Item created successfully'
});

Update Item by Id

Example request/response

let dto = {
  "Cost": "5.00"
}

fetch(`https://developers.knowify.com/api/v1/items/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Item updated successfully'
});

Update Item by Id

Example request/response

let dto = {
  "Price": "10.00"
}

fetch(`https://developers.knowify.com/api/v1/items/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Item updated successfully'
});

Update Item by Id

Example request/response

let dto = {
  "Name": "Example Name"
}

fetch(`https://developers.knowify.com/api/v1/items/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Item updated successfully'
});

Update Item by Id

Example request/response

let dto = {
  "Description": "A simple description"
}

fetch(`https://developers.knowify.com/api/v1/items/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Item updated successfully'
});

Delete Item

fetch(`https://developers.knowify.com/api/v1/items/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Item removed successfully'
});

Create Milestone

Example request/response

let dto = {
  "Budget": "1020.00",
  "BudgetLabor": "900.00",
  "BudgetSubs": "120.00",
  "DateRange": {
    "StartDate": "2024-11-13T12:00:00.000Z",
    "FinishDate": "2024-11-15T12:00:00.000Z"
  },
  "Description": "A simple description",
  "EstimatedItems": [],
  "IsSub": false,
  "Name": "Example Name",
  "ProjectPlanId": 111111,
  "Scheduled": false,
  "Tasks": [],
  "TasksEnabled": false
}

fetch('https://developers.knowify.com/api/v1/milestones', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Milestone created successfully'
});

Update Milestone by Id

Example request/response

let dto = {
  "Budget": "1020.00",
  "BudgetLabor": "900.00",
  "BudgetSubs": "120.00",
  "DateRange": {
    "StartDate": "2024-11-13T12:00:00.000Z",
    "FinishDate": "2024-11-15T12:00:00.000Z"
  },
  "Description": "A simple description",
  "EstimatedItems": [],
  "IsSub": false,
  "Name": "Example Name",
  "ProjectPlanId": 111111,
  "Scheduled": false,
  "Tasks": [],
  "TasksEnabled": false
}

fetch(`https://developers.knowify.com/api/v1/milestones/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Milestone updated successfully'
});

Delete Milestone

fetch(`https://developers.knowify.com/api/v1/milestones/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Milestone removed successfully'
});

Fetch All Payments

Fetch All Payments with options

Fetch Payment by Id

Fetch Payment by Id with options

Fetch Payments since date

Fetch Payments since date with options

fetch('https://developers.knowify.com/api/v1/payments', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Payments*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Payment

Example request/response

let dto = {
  "FieldName": "Description"
}

fetch('https://developers.knowify.com/api/v1/payments', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Payment created successfully'
});

Update Payment by Id

Example request/response

let dto = {
  "FieldName": "Description"
}

fetch(`https://developers.knowify.com/api/v1/payments/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Payment updated successfully'
});

Delete Payment

fetch(`https://developers.knowify.com/api/v1/payments/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Payment removed successfully'
});

Fetch All Projects

Fetch All Projects with options

Fetch Project by Id

Fetch Project by Id with options

Fetch Projects since date

Fetch Projects since date with options

fetch('https://developers.knowify.com/api/v1/projects', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Projects*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Fetch All Purchases

Fetch All Purchases with options

Fetch Purchase by Id

Fetch Purchase by Id with options

Fetch Purchases since date

Fetch Purchases since date with options

fetch('https://developers.knowify.com/api/v1/purchases', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Purchases*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Delete Purchase

fetch(`https://developers.knowify.com/api/v1/purchases/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Purchase removed successfully'
});

Fetch All Resources

Fetch All Resources with options

Fetch Resource by Id

Fetch Resource by Id with options

Fetch Resources since date

Fetch Resources since date with options

fetch('https://developers.knowify.com/api/v1/resources', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Resources*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Resource

Example request/response

let dto = {
  "Description": "Jane Doe",
  "DepartmentId": "4"
}

fetch('https://developers.knowify.com/api/v1/resources', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Resource created successfully'
});

Update Resource by Id

Example request/response

let dto = {
  "Description": "Jane Doe",
  "DepartmentId": "4"
}

fetch(`https://developers.knowify.com/api/v1/resources/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Resource updated successfully'
});

Delete Resource

fetch(`https://developers.knowify.com/api/v1/resources/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Resource removed successfully'
});

Fetch All Tickets

Fetch All Tickets with options

Fetch Ticket by Id

Fetch Ticket by Id with options

Fetch Tickets since date

Fetch Tickets since date with options

fetch('https://developers.knowify.com/api/v1/tickets', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Tickets*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Ticket

Example request/response

let dto = {
  "Address1": "228 Market Street",
  "City": "Philadelphia",
  "ClientId": "2",
  "Country": "US",
  "DisplayDate": "2024-11-14T12:00:00.000Z",
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "MaterialsIncluded": false,
  "ResourceIds": [],
  "ServiceItems": [],
  "StateProvince": "Pennsylvania",
  "Title": "Service Ticket #000007",
  "Zip": "19106"
}

fetch('https://developers.knowify.com/api/v1/tickets', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Ticket created successfully'
});

Create Ticket

Example request/response

let dto = {
  "Address1": "228 Market Street",
  "City": "Philadelphia",
  "ClientId": "2",
  "Country": "US",
  "DisplayDate": "2024-11-14T12:00:00.000Z",
  "EndTime": "2024-11-16T03:00:00.000Z",
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "MaterialsIncluded": false,
  "ResourceIds": [
    "17"
  ],
  "ServiceItems": [
    {
      "CatalogId": 307,
      "Price": "2.00",
      "Quantity": 1,
      "Name": "Screws",
      "Cost": "1.00",
      "Subtotal": 2
    }
  ],
  "StartTime": "2024-11-13T21:15:00.000Z",
  "StateProvince": "Pennsylvania",
  "Title": "Service Ticket #000007",
  "Zip": "19106"
}

fetch('https://developers.knowify.com/api/v1/tickets', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Ticket created successfully'
});

Create Ticket

Example request/response

let dto = {
  "Address1": "228 Market Street",
  "City": "Philadelphia",
  "ClientId": "2",
  "Country": "US",
  "DisplayDate": "2024-11-14T12:00:00.000Z",
  "EndTime": "2024-11-16T03:00:00.000Z",
  "IsTM": true,
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "MaterialsIncluded": false,
  "ResourceIds": [
    "17"
  ],
  "ServiceItems": [],
  "StartTime": "2024-11-13T21:15:00.000Z",
  "StateProvince": "Pennsylvania",
  "Title": "Service Ticket #000007",
  "Zip": "19106"
}

fetch('https://developers.knowify.com/api/v1/tickets', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Ticket created successfully'
});

Update Ticket by Id

Example request/response

let dto = {
  "Address1": "228 Market Street",
  "City": "Philadelphia",
  "Country": "US",
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "StateProvince": "Pennsylvania",
  "Zip": "19106"
}

fetch(`https://developers.knowify.com/api/v1/tickets/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Ticket updated successfully'
});

Update Ticket by Id

Example request/response

let dto = {
  "ResourceIds": [
    "17"
  ]
}

fetch(`https://developers.knowify.com/api/v1/tickets/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Ticket updated successfully'
});

Update Ticket by Id

Example request/response

let dto = {
  "DisplayDate": "2024-11-14T12:00:00.000Z",
  "EndTime": "2024-11-16T03:00:00.000Z",
  "StartTime": "2024-11-13T21:15:00.000Z"
}

fetch(`https://developers.knowify.com/api/v1/tickets/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Ticket updated successfully'
});

Update Ticket by Id

Example request/response

let dto = {
  "ServiceItems": [
    {
      "CatalogId": 307,
      "Price": "2.00",
      "Quantity": 1,
      "Name": "Screws",
      "Cost": "1.00",
      "Subtotal": 2
    }
  ]
}

fetch(`https://developers.knowify.com/api/v1/tickets/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Ticket updated successfully'
});

Delete Ticket

fetch(`https://developers.knowify.com/api/v1/tickets/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Ticket removed successfully'
});

Fetch All Time

Fetch All Time with options

Fetch Time by Id

Fetch Time by Id with options

Fetch Time since date

Fetch Time since date with options

fetch('https://developers.knowify.com/api/v1/time', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Time*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Time

Example request/response

let dto = {
  "EntryDate": "2024-11-14T12:00:00.000Z",
  "ResourceId": "17",
  "Time": "3.40 (3h 40m)",
  "ProjectId": "14",
  "MilestoneId": "20",
  "TaskId": "24"
}

fetch('https://developers.knowify.com/api/v1/time', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Time created successfully'
});

Create Check-in

Example request/response

let dto = {
  "EntryDate": "2024-11-14T12:00:00.000Z",
  "ResourceId": "17",
  "TimeIn": "2024-11-14T21:15:00.000Z",
  "ProjectId": "14",
  "MilestoneId": "20",
  "TaskId": "24",
  "LocationIn": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  }
}

fetch('https://developers.knowify.com/api/v1/time/check-in', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Time created successfully'
});

Update Check-out by Id

Example request/response

let dto = {
  "Time": "2024-11-16T03:00:00.000Z",
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "Comment": "Example value",
  "UserDescription": "Example value",
  "AdjustedTime": "-1.15",
  "ManuallyEdited": false
}

fetch(`https://developers.knowify.com/api/v1/time/check-out/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Time updated successfully'
});

Update Time by Id

Example request/response

let dto = {}

fetch(`https://developers.knowify.com/api/v1/time/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Time updated successfully'
});

Delete Time

fetch(`https://developers.knowify.com/api/v1/time/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Time removed successfully'
});

Fetch All Vendors

Fetch All Vendors with options

Fetch Vendor by Id

Fetch Vendor by Id with options

Fetch Vendors since date

Fetch Vendors since date with options

fetch('https://developers.knowify.com/api/v1/vendors', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Vendors*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Vendor

Example request/response

let dto = {
  "VendorName": "New Vendor Name"
}

fetch('https://developers.knowify.com/api/v1/vendors', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Vendor created successfully'
});

Update Vendor by Id

Example request/response

let dto = {
  "Address1": "228 Market Street",
  "City": "Philadelphia",
  "Country": "US",
  "Location": {
    "GeoJson": "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[40.722337,-73.994885]},\"properties\":{\"timestamp\":\"2016-02-26T20:45:49.467Z\",\"address_components\":{\"Address1\":\"228 Market Street\",\"Address2\":null,\"City\":\"Philadelphia\",\"StateProvince\":\"Pennsylvania\",\"Zip\":\"19106\",\"Country\":\"US\"},\"formatted_address\":\"228 Market Street, Philadelphia, Pennsylvania, US 19106\",\"location_label\":\"Service Ticket #000007\"}}"
  },
  "StateProvince": "Pennsylvania",
  "Zip": "19106"
}

fetch(`https://developers.knowify.com/api/v1/vendors/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Vendor updated successfully'
});

Update Vendor by Id

Example request/response

let dto = {
  "ContactName": "Jane Doe",
  "Phone": "16177850630",
  "Email": "jane.doe@company.com",
  "Website": "http://www.example.com"
}

fetch(`https://developers.knowify.com/api/v1/vendors/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Vendor updated successfully'
});

Delete Vendor

fetch(`https://developers.knowify.com/api/v1/vendors/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Vendor removed successfully'
});

{
    "Id": "Number?",
    "ResourceIds": "Array.<Number|String>",
    "ResourceId": "Number?|String?",
    "JobRoleId": "Number?|String?",
    "Description": "String",
    "Rate": "Number",
    "Duration": "String",
    "StartTime": "String",
    "EndTime": "String",
    "RecurUntilDate": "String",
    "IsMultiDay": "Boolean",
    "IsRecurring": "Boolean",
    "TracksTime": "Boolean",
    "Periodicity": "String",
    "IsTimeOff": "Boolean",
    "IsBillable": "Boolean",
    "IncludesOffDays": "Boolean",
    "ForClient": "Boolean",
    "ClientId": "Number?|String?",
    "Client": "Client",
    "DepartmentId": "Number?|String?",
    "Department": "Department",
    "ProjectId": "Number?|String?",
    "Project": "Project",
    "MilestoneId": "Number?|String?]",
    "Milestone": "Milestone",
    "TaskId": "Number?|String?",
    "Task": "Task",
    "RoleResourceId": "Number?|String?",
    "AllocationType": "String",
    "TimeOffCategory": "String",
    "GroupId": "String",
    "EditAll": "Boolean",
    "ServiceTicketId": "Number?|String?",
    "TimeEntryId": "Number?|String?",
    "TimeEntries": "Array.<TimeEntry>"
}

{
    "Id": "String",
    "DueDate": "String",
    "InvoiceDate": "String",
    "TypeOfPayable": "String",
    "VendorId": "String",
    "Vendor": "Vendor",
    "TotalAmount": "String",
    "OutstandingAmount": "String",
    "InvoiceNumber": "String",
    "ReviewerId": "String",
    "ReviewerName": "String",
    "PONumber": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "NeedsToBeSynced": "Boolean",
    "DateLastSynced": "String",
    "DateClosed": "String",
    "IsReimbursement": "Boolean",
    "IsCreditCardBill": "Boolean",
    "ExpenseAccountId": "String",
    "PaymentAccountId": "String",
    "BusinessState": "String",
    "HasItemsPending": "Boolean",
    "HasMultipleAllocations": "Boolean",
    "RelatedRequestsBalance": "String",
    "SupportingDocuments": "Array.<Document>",
    "RequestInfoFlag": "Boolean",
    "UnderReviewFlag": "Boolean",
    "ManagerOKFlag": "Boolean",
    "RejectedFlag": "Boolean",
    "NewVendorFlag": "Boolean",
    "ReimbursementFlag": "Boolean",
    "NewClientFlag": "Boolean",
    "HasPayments": "Boolean",
    "Payments": "Array.<Payment>",
    "PayableItems": "Array.<PayableItem>",
    "AmountPaid": "String",
    "PriorBalance": "String",
    "InfoRequested": "Boolean",
    "PersonToBeReimbursedId": "Number",
    "ForDeptClient": "Boolean",
    "ForProjBudget": "Boolean",
    "Invoice": "DocumentDto",
    "RequestAllocations": "Array.<RequestAllocation>",
    "AssociatedId": "String",
    "UserActions": "Array.<UserAction>",
    "Comments": "Array.<Comment>"
}

{
    "Id": "String",
    "ClientId": "String",
    "ClientParentId": "Number",
    "ProjectId": "String",
    "Project": "Object.<ProjectName:String>",
    "MilestoneId": "String",
    "DeliverableId": "String",
    "EstimatedItemId": "String",
    "DeliverableName": "String",
    "TaskId": "String",
    "OriginOfBillable": "String",
    "OriginOfBillableId": "Number",
    "ParentRequestId": "Number?|String?",
    "Description": "String",
    "Hours": "String",
    "HoursRemaining": "String",
    "Price": "String",
    "OurCost": "String",
    "UnitPrice": "String",
    "Quantity": "String",
    "QuantityRemaining": "String",
    "DefaultQuantity": "String",
    "DefaultTaxable": "Boolean",
    "IsInvoiced": "Boolean",
    "InvoiceNumber": "String",
    "LineItemId": "String",
    "Markup": "String",
    "LineItemPointers": "Array.<LineItemPointer>",
    "BusinessState": "String",
    "DueDate": "String",
    "StartDate": "String",
    "Comment": "Comment",
    "PriceRemaining": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "NeedsToBeSynced": "Boolean",
    "SyncError": "Boolean",
    "DateLastSynced": "String",
    "CatalogId": "Number?|String?"
}

{
    "Id": "Number",
    "Name": "String"
}

{
    "Id": "Number",
    "ClientName": "String",
    "CompanyName": "String",
    "ContactName": "String",
    "Address1": "String",
    "Address2": "String",
    "City": "String",
    "Zip": "String",
    "Country": "String",
    "StateProvince": "String",
    "SameAsBilling": "Boolean",
    "ShippingContact": "String",
    "ShippingAddress1": "String",
    "ShippingAddress2": "String",
    "ShippingCity": "String",
    "ShippingStateProvince": "String",
    "ShippingZip": "String",
    "ShippingCountry": "String",
    "Email": "String",
    "Website": "String",
    "PhoneNumber": "String",
    "TaxCode": "String",
    "IncomeAccount": "String",
    "IncomeAccountId": "String",
    "PaymentAccount": "String",
    "PaymentAccountId": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "NeedsToBeSynced": "Boolean",
    "SyncError": "Boolean",
    "DateLastSynced": "String",
    "BillingInstructions": "String",
    "ObjectState": "String",
    "QBParentId": "String",
    "ParentName": "String",
    "ParentId": "Number?|String?",
    "Location": {
        "GeoJson": "GeoJSON"
    },
    "DefaultProjectId": "Number?|String?",
    "DefaultMilestoneId": "Number?|String?",
    "DefaultTaskId": "Number?|String?",
    "Contacts": "Array.<Contact>"
}

{
    "RelatedObjectId": "String",
    "Text": "String",
    "ProjectId": "Number?",
    "CreatedBy": "Number",
    "UserName": "String"
}

{
    "Id": "Number",
    "ClientId": "Number",
    "ContactName": "String",
    "Email": "String",
    "Phone": "String"
}

{
    "StartDate": "String?",
    "FinishDate": "String?",
    "StartTime": "String?",
    "EndTime": "String?"
}

{
    "Id": "Number",
    "DepartmentName": "String",
    "DefaultProjectId": "Number?",
    "DefaultMilestoneId": "Number?",
    "DefaultTaskId": "Number?"
}

{
    "Id": "String",
    "RelatedObjectId": "String",
    "FileName": "String",
    "FileType": "String",
    "File": "String",
    "AssociatedEntityType": "String",
    "ShareMobile": "Boolean"
}

{
    "Id": "Array.<Number>",
    "Description": "String",
    "Quantity": "String",
    "Price": "String",
    "CatalogId": "Array.<Number>",
    "IsExcluded": "Boolean"
}

{
    "Id": "String",
    "HeaderText": "String",
    "FooterText": "String",
    "ClientId": "String",
    "Client": "Client",
    "ProjectId": "String",
    "Project": "Project",
    "InvoiceNumber": "String",
    "LineItemGroups": "LineItemGroup",
    "Comments": "Array.<Comment>",
    "PaymentTerms": "String",
    "BusinessState": "String",
    "IncomeAccountId": "String",
    "IncludeTimeReport": "Boolean",
    "PaymentAccountId": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "NeedsToBeSynced": "Boolean",
    "SyncError": "Boolean",
    "DateLastSynced": "String",
    "Payments": "Array.<Payment>",
    "UserActions": "Array.<UserAction>",
    "TotalAmount": "String",
    "OutstandingAmount": "String",
    "DueDate": "String",
    "StartDate": "String",
    "EndDate": "String",
    "InvoiceDate": "String",
    "PDF": "Document",
    "Credit": "String",
    "Shipping": "String",
    "TotalTaxes": "String",
    "TaxRateId": "String",
    "TaxCodeId": "String",
    "TaxRate": "String",
    "ContactName": "String",
    "ContactEmail": "String",
    "IsTaxable": "Boolean",
    "ToVerify": "Boolean",
    "AutoInvoice": "Boolean",
    "Deposits": "Array.<LineItem>",
    "ForDeposit": "Boolean",
    "ClientEmail": "String"
}

{
    "Id": "Number",
    "Name": "String",
    "Description": "String",
    "BillingPeriodicity": "String",
    "FinancialTerms": "String",
    "IsTieredPricing": "Boolean",
    "TieredPricing": "Array.<TieredPricing>",
    "EstimatedItems": "Array.<EstimatedItem>",
    "Price": "String",
    "OurCost": "String",
    "UnitName": "String",
    "RoleResourceRates": "Array.<RoleResourceRate>",
    "Categories": "Array.<Category>",
    "MaterialsIncludedInPrice": "Boolean",
    "Hours": "String",
    "Minutes": "String",
    "ObjectState": "String",
    "QBItemType": "String",
    "QBId": "String",
    "QBParentId": "String",
    "QBSyncToken": "String",
    "NeedsToBeSynced": "Boolean",
    "SyncError": "Boolean",
    "DateLastSynced": "String",
    "ExpenseAccountId": "String",
    "IncomeAccountId": "String",
    "Taxable": "Boolean",
    "ItemNumber": "String",
    "VendorId": "Number",
    "ParentId": "Number"
}

{
    "Id": "Number?|String?",
    "Description": "String",
    "Quantity": "String",
    "DefaultQuantity": "String",
    "Price": "String",
    "UnitPrice": "String",
    "Markup": "String",
    "IsTaxable": "Boolean",
    "ToVerify": "Boolean",
    "Total": "String",
    "TaxRate": "String",
    "TaxRateId": "String",
    "TaxCodeId": "String",
    "BillableId": "String",
    "Billable": "Billable",
    "SequenceNumber": "String",
    "IsPartialTime": "Boolean",
    "IsPartialQuantity": "Boolean",
    "ClassId": "String",
    "ProjectId": "Number?|String?",
    "MilestoneId": "Number?|String?",
    "IsDeposit": "Boolean",
    "DeliverableId": "Number?|String?",
    "CatalogId": "Number?|String?"
}

{
    "Id": "Number?|String?",
    "GroupHeader": "String",
    "GroupQuantity": "String",
    "SequenceNumber": "String",
    "ShowGroup": "Boolean",
    "LineItems": "Array.<LineItem>",
    "AutoGroup": "Boolean"
}

{
    "Budget": "String",
    "BusinessState": "String",
    "CatalogId": "Number?",
    "Collapsed": "Boolean",
    "Comments": "Array.<Comment>",
    "DateRange": "DateRange",
    "DeliverableId": "String",
    "Description": "String",
    "EstimatedItems": "Array.<EstimatedItem>",
    "Id": "String",
    "IsDefault": "Boolean",
    "BudgetLabor": "String",
    "IsDeliverableClosed": "Boolean",
    "IsGoodForAllocation": "Boolean",
    "IsSub": "Boolean",
    "IsUsed": "Boolean",
    "MaterialsTotal": "String",
    "BudgetSubs": "String",
    "OrderNumber": "Number?",
    "VendorId": "Number?",
    "NumDays": "Number?",
    "ProjectPlanId": "String",
    "Scheduled": "Boolean",
    "LaborEnabled": "Boolean",
    "ServiceTicketId": "Number?",
    "Tasks": "Array.<Task>",
    "TasksEnabled": "Boolean",
    "TemplateUnits": "Number?",
    "TimeTotal": "String",
    "WorkOrder": "String"
}

{
    "Id": "Number",
    "Description": "String",
    "Description2": "String",
    "TotalAmount": "String",
    "Quantity": "String",
    "PayableId": "Number",
    "RequestItemId": "Number?|String?",
    "RequestId": "Number?|String?",
    "PONumber": "String",
    "ClientId": "Number?|String?",
    "ClientQBId": "String",
    "DepartmentId": "Number?|String?",
    "MilestoneId": "Number?|String?",
    "ProjectId": "Number?|String?",
    "VendorId": "Number?|String?",
    "VendorName": "String",
    "Account": "String",
    "ClassId": "String",
    "IsExcluded": "Boolean"
}

{
    "Amount": "String",
    "PaymentDate": "String",
    "CloseRequestsIfItemsPending": "Boolean",
    "CloseRequestsIfMultipleAllocations": "Boolean",
    "CloseRequestsIfPaymentAmountLess": "Boolean",
    "AlreadyPaid": "Boolean",
    "QBCheck": "Boolean"
}

{
    "Address1": "String",
    "Address2": "String",
    "BudgetAmount": "String",
    "BusinessState": "String",
    "CanBeDeleted": "Boolean",
    "City": "String",
    "ClassQBId": "String",
    "Client": "ClientDto",
    "ClientId": "String",
    "CloseDate": "String",
    "Color": "String",
    "Contract": "ContractDto",
    "ContractId": "String",
    "ContractType": "String",
    "Country": "String",
    "Custom1": "String",
    "Custom2": "String",
    "DateRange": "DateRange",
    "Department": "DepartmentDto",
    "DepartmentId": "String",
    "DraftContract": "ContractDto",
    "DraftContractId": "String",
    "DueDate": "String",
    "ExpenseAccountId": "String",
    "ForClient": "Boolean",
    "HasContract": "Boolean",
    "HasMaterials": "Boolean",
    "HasNoBudget": "Boolean",
    "HasTime": "Boolean",
    "Id": "Number",
    "IncomeAccountId": "String",
    "IsClosed": "Boolean",
    "IsDefaultProject": "Boolean",
    "IsLocked": "Boolean",
    "JobCostingMode": "String",
    "LaborEstimated": "String",
    "LaborTracked": "String",
    "Location": {
        "GeoJson": "String?"
    },
    "MaterialsEstimated": "String",
    "MaterialsTracked": "String",
    "Notes": "String",
    "NoTimeframe": "Boolean",
    "OwnerId": "String",
    "ProjectName": "String",
    "ProjectPlan": "ProjectPlanDto",
    "ProjectPlanEnabled": "Boolean",
    "ProjectPlanId": "String",
    "RFISeed": "String",
    "Scheduled": "Boolean",
    "ServiceTicketId": "Array?<Number>",
    "StateProvince": "String",
    "SubclientId": "Array?<Number>",
    "SubsEstimated": "String",
    "SubsTracked": "String",
    "SupportingDocuments": "Array<DocumentDto>",
    "Tags": "Array<TagDto>",
    "UserActions": "Array<UserActionDto>",
    "Zip": "String"
}

{
    "RequestId": "String",
    "PONumber": "String",
    "Amount": "String"
}

{
    "Id": "Number?",
    "ObjectState": "String",
    "ResourceName": "String",
    "UserId": "Number?",
    "RoleId": "Number?",
    "JobRole": "String",
    "DepartmentId": "Number?",
    "ResourceType": "String",
    "Description": "String",
    "IsBillable": "Boolean",
    "Rate": "String",
    "Cost": "String",
    "Benefits": "String",
    "CostType": "String",
    "OverTimeEligible": "Boolean",
    "UnionPerHour": "String",
    "Taxes": "String",
    "Insurance": "String",
    "Other": "String",
    "VendorId": "Number?"
}

{
    "Id": "String",
    "DisplayName": "String",
    "RoleResourceId": "Number",
    "EstimatedHours": "String",
    "IsRole": "Boolean",
    "DateRange": "DateRange",
    "HoursSubmitted": "String",
    "HoursApproved": "String",
    "NonPlan": "Boolean",
    "HourlyRate": "String",
    "TimeEntryId": "Number?",
    "Scheduled": "Boolean",
    "InEstimate": "Boolean"
}

{
    "Id": "Number",
    "DisplayName": "String",
    "RoleResourceId": "String",
    "Rate": "String",
    "RateType": "String",
    "EstimatedHours": "String"
}

{
    "CatalogId": "Number|String",
    "Cost": "String",
    "Description": "String",
    "Name": "String",
    "Price": "String",
    "Quantity": "Number",
    "Subtotal": "String"
}

{
    "Id": "String",
    "MilestoneId": "String",
    "BusinessState": "String",
    "Description": "String",
    "DateRange": "DateRange",
    "IsDefault": "Boolean",
    "IsUsed": "Boolean",
    "RoleResources": "Array.<RoleResource>",
    "Comments": "Array.<Comment>",
    "NumDays": "Number?",
    "ProjectId": "Number?",
    "CatalogId": "Number?",
    "Priority": "Number",
    "Scheduled": "Boolean",
    "DateCompleted": "String"
}

{
    "Address1": "String",
    "Address2": "String?",
    "City": "String",
    "ClientId": "Number",
    "Country": "String",
    "Date": "String",
    "DisplayDate": "String",
    "Duration": "String?",
    "Email": "String",
    "EndTime": "String",
    "Hours": "String",
    "IsTM": "Boolean",
    "Description": "String",
    "Comments": [],
    "Location": {
        "GeoJson": "String?"
    },
    "MaterialsIncluded": "Boolean",
    "Phone": "String",
    "ResourceIds": "Array.<Number|String>",
    "ServiceItems": "Array.<ServiceItem>",
    "StartTime": "String",
    "StateProvince": "String",
    "Title": "String",
    "Zip": "String"
}

{
    "Id": "Array.<Number>",
    "Start": "String",
    "End": "String",
    "Price": "String"
}

{
    "Id": "Number",
    "AuthId": "Number",
    "FirstName": "String",
    "MiddleName": "String",
    "LastName": "String",
    "FullName": "String",
    "Email": "String",
    "Password": "String",
    "DepartmentId": "Number",
    "DirectManagerId": "Number?",
    "JobRole": "JobRoleDto",
    "UserRights": "Array.<UserRightDto>",
    "UserGuideTrackers": "Array.<UserGuideTrackerDto>",
    "ManagementTree": "Array.<UserDto>",
    "IsManager": "Boolean",
    "IsSetupAdmin": "Boolean",
    "IsNew": "Boolean",
    "ApprovalThreshold": "String",
    "UnlimitedAuthority": "Boolean",
    "Department": "DepartmentDto",
    "Enabled": "Number",
    "QBId": "String",
    "Currency": "String",
    "ReimbursementVendorId": "String",
    "Access": "Boolean",
    "Username": "String",
    "NonAccessName": "String"
}

{
    "Id": "String",
    "UserName": "String",
    "DateCreated": "String",
    "ActionName": "String",
    "EntityType": "String",
    "EntityId": "String",
    "CreatedBy": "Number"
}

{
    "Id": "Number",
    "VendorName": "String",
    "CompanyName": "String",
    "CreatedBy": "String",
    "ModifiedBy": "String",
    "Address1": "String",
    "Address2": "String",
    "City": "String",
    "Email": "String",
    "ContactName": "String",
    "Website": "String",
    "Country": "String",
    "StateProvince": "String",
    "Zip": "String",
    "ExpenseAccount": "String",
    "ExpenseAccountId": "String",
    "PaymentAccount": "String",
    "PaymentAccountId": "String",
    "PhoneNumber": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "NeedsToBeSynced": "Boolean",
    "SyncError": "Boolean",
    "DateLastSynced": "String",
    "ObjectState": "String",
    "Vendor1099": "Boolean",
    "JobRole": "String"
}

Create Account

Example request/response

let dto = {
  "AccountName": "John Doezer",
  "AccountType": "SomeType",
  "QBId": "12332-3453-34535",
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "DateLastSynced": "2024-11-14T12:00:00.000Z",
  "AccountNumber": "28347834-23895720-3242",
  "CurrentBalance": "123445.93"
}

fetch('https://developers.knowify.com/api/v1/qbd/account', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Account created successfully'
});

Update Account by Id

Example request/response

let dto = {
  "AccountName": "John Doezer",
  "AccountType": "SomeType",
  "QBId": "12332-3453-34535",
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "DateLastSynced": "2024-11-14T12:00:00.000Z",
  "AccountNumber": "28347834-23895720-3242",
  "CurrentBalance": "123445.93"
}

fetch(`https://developers.knowify.com/api/v1/qbd/account/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Account updated successfully'
});

Delete Account

fetch(`https://developers.knowify.com/api/v1/qbd/accounts/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Account removed successfully'
});

Check Client For Knowify Id

fetch('https://developers.knowify.com/api/v1/check_qb_client', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Check_QB_Client*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Check Item For Knowify Id

fetch('https://developers.knowify.com/api/v1/check_qb_item', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Check_QB_Item*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Check Vendor For Knowify Id

fetch('https://developers.knowify.com/api/v1/check_qb_vendor', {
  method: 'GET',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;
  expect(body.data).to.be.an.array; // all Check_QB_Vendor*
  expect(body.status).to.be.a.number;
  expect(body.message).to.be.a.string;
});
// * only when the user has permissions to view the data

Create Employee

Example request/response

let dto = {
  "DisplayName": "Example Name",
  "QBId": "12332-3453-34535",
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch('https://developers.knowify.com/api/v1/qbd/employees', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Employee created successfully'
});

Update Employee by Id

Example request/response

let dto = {
  "DisplayName": "Example Name",
  "QBId": "12332-3453-34535",
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch(`https://developers.knowify.com/api/v1/qbd/employees/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Employee updated successfully'
});

Delete Employee

fetch(`https://developers.knowify.com/api/v1/qbd/employees/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Employee removed successfully'
});

Create Payment_term

Example request/response

let dto = {
  "QBId": "12332-3453-34535",
  "Name": "Example Name",
  "PaymentTerm": "NET30",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch('https://developers.knowify.com/api/v1/qbd/payment_terms', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Payment Term created successfully'
});

Update Payment_term by Id

Example request/response

let dto = {
  "QBId": "12332-3453-34535",
  "Name": "Example Name",
  "PaymentTerm": "NET30",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch(`https://developers.knowify.com/api/v1/qbd/payment_terms/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Payment Term updated successfully'
});

Delete Payment_term

fetch(`https://developers.knowify.com/api/v1/qbd/payment_terms/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Payment Term removed successfully'
});

Create Tax_code

Example request/response

let dto = {
  "Name": "Example Name",
  "QBId": "12332-3453-34535",
  "TaxRateDetails": [
    {
      "Amount": "123.45",
      "QBTaxCodeId": "123",
      "QBId": "12332-3453-34535"
    }
  ],
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch('https://developers.knowify.com/api/v1/qbd/tax_codes', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Tax Code created successfully'
});

Update Tax_code by Id

Example request/response

let dto = {
  "Name": "Example Name",
  "QBId": "12332-3453-34535",
  "TaxRateDetails": [
    {
      "Amount": "123.45",
      "QBTaxCodeId": "123",
      "QBId": "12332-3453-34535"
    }
  ],
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch(`https://developers.knowify.com/api/v1/qbd/tax_codes/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Tax Code updated successfully'
});

Delete Tax_code

fetch(`https://developers.knowify.com/api/v1/qbd/tax_codes/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Tax Code removed successfully'
});

Create Tax_rate

Example request/response

let dto = {
  "Name": "Example Name",
  "QBId": "12332-3453-34535",
  "QBTaxCodeId": "123",
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "Amount": "123.45",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch('https://developers.knowify.com/api/v1/qbd/tax_rates', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of newly created object
  expect(body.status).to.be.a.number;         // 201
  expect(body.message).to.be.a.string;        // 'Tax Rate created successfully'
});

Update Tax_rate by Id

Example request/response

let dto = {
  "Name": "Example Name",
  "QBId": "12332-3453-34535",
  "QBTaxCodeId": "123",
  "QBSyncToken": "khwefiqbwef98324fubieurkcv7q34",
  "Amount": "123.45",
  "DateLastSynced": "2024-11-14T12:00:00.000Z"
}

fetch(`https://developers.knowify.com/api/v1/qbd/tax_rates/${id}`, {
  method: 'PUT',
  headers: { Authorization: `Bearer ${accessToken}` },
  body: JSON.stringify(dto)
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of updated object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Tax Rate updated successfully'
});

Delete Tax_rate

fetch(`https://developers.knowify.com/api/v1/qbd/tax_rates/${id}`, {
  method: 'DELETE',
  headers: { Authorization: `Bearer ${accessToken}` }
})
.then(response => response.json())
.then(body => {
  expect(body.didSucceed).to.be.a.boolean;    // true
  expect(parseInt(body.data)).to.be.a.number; // Id of deleted object
  expect(body.status).to.be.a.number;         // 200
  expect(body.message).to.be.a.string;        // 'Tax Rate removed successfully'
});

{
    "Id": "Number?",
    "AccountName": "String",
    "AccountType": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "DateLastSynced": "DateTimeString?",
    "AccountNumber": "String",
    "CurrentBalance": "String"
}

{
    "Id": "Number",
    "Name": "String",
    "FullyQualifiedName": "String",
    "SubClass": "Boolean",
    "QBId": "String",
    "DateLastSynced": "Date"
}

{
    "Id": "Number?",
    "DisplayName": "String",
    "QBId": "String",
    "QBSyncToken": "String",
    "DateLastSynced": "DateTimeString?"
}

{
    "Id": "Number?",
    "Name": "String",
    "QBId": "String",
    "PaymentTerm": "String",
    "DateLastSynced": "DateTimeString?"
}

{
    "Id": "Number?",
    "Name": "String",
    "QBId": "String",
    "TaxRateDetails": "Array.<QBTaxRate>",
    "QBSyncToken": "String",
    "DateLastSynced": "DateTimeString?"
}

{
    "Id": "Number?",
    "Name": "String",
    "QBId": "String",
    "QBTaxCodeId": "String",
    "QBSyncToken": "String",
    "Amount": "String",
    "DateLastSynced": "DateTimeString?"
}