Here are some guildelines integration for Kinow Server API with available resources and good practices.
Server API usage
This API is working with Rest/JSON.
It allows to integrate all resources linked to a Kinow video platform inside an existing website, for example video list from CMS or user account information's.
This API also allows to edit data on-the-fly or create new ones, so it provides administrator context access with write rights on all platform data.
It’s also very powerful for mass actions, like synchronizing user accounts with an external SSO.
Online documentation is available on https://api.kinow.com and introduce a tutorial to learn the Server API usage.
The API Reference lists all available methods (https://api.kinow.com/api-reference.html) and allows to do API calls directly in the web UI.
Kinow provides a system to receive notifications on a entrypoint (webhook mechanism) in order to be notified of any change made on existing object inside the backend (eg. customer account, catalog content, etc).
Various events are implemented and send the objects affected by the changes directly inside the notification. A signature is also given to check the data authenticity.
Available events are listed on the online documentation: https://github.com/kinow-io/kinow-webhooks
Kinow API observes a rate limitation, with a maximum number of requests allowed to be thrown per minute. If this maximum is exceeded, the application is no longer allowed to contact the API for a laps of time.
Cache API token
Token generation, using your API keys-pair to use the API via the route "get-token", return a temporary token which is valid for one hour.
It's useless to call route "get-token" for each of your API processes: it's imperative to store the token generated inside a local cache, and re-use it until its expiration.
Once token is expired, you just have to generate a new one by calling route "get-token".
Cache API responses
To minimize the number of requests done to the API, and the latency that may result depending on the request data complexity, it's imperative to create a local cache with the API data returned.
This is very important in order to increase the application performance (limiting calls number, increasing the overall response time) and support a high level of traffic.
It's therefore necessary to make each API call once, and put the returned data in a local cache (for example Memcache, Redis or a relational database like MySQL) rather than making the calls with each page load.
You can populate the data displayed on your page using the local cache instead of a redundant JSON format.
Webhook notifications are then used to update cached data in real time, without manually resynchronizing all data.