Introduction

YellowSchedule is a secure platform for scheduling appointments with clients, and storing and tracking client (patient) details. This API allows developers to write functions to allow other systems to integrate directly with YellowSchedule. This can allows other system to, for example, create or view contacts or appointments directly in YellowSchedule.

Things you should know:

• This API is organised around RESTful web services and all API requests return JSON responses.
• Keep your API Key(s) safe. You should never expose your secret API Key in public client side source code or publicly accessible areas such GitHub.
• If you just want to take appointment bookings on your website, you do not need this API. We have easy to add booking widget which plug into any website. The API is not required for using our booking widget - you simply include a snippet of code onto your website source code to use the booking widget. The snippet is available by going to "Settings" (top right menu) >> "Install code" and can simply be pasted in your website source. Additionally we also have Wordpress, Joomla, and Drupal Plugins for the booking widget). More on setting up live bookings on your website WITHOUT requiring the use of this API.

Key Features

Authentication

Authenticate your account when using the API by including your secret API key in the header of the request. Manage your API keys within the YellowSchedule App. Keys can be refreshed to ensure access is controlled and keys can be revoked if API access is no longer required.

All API requests must have a valid API key as part of the header of the request. The following example shows a CURL call to request all services on the account.

$ curl -H "Authorization: bearer *-API Key-*" https://www.yellowschedule.com/app/api/v2/services -X GET

$url = "https://www.yellowschedule.com/app/api/v2/services";
$APItoken =*-API Key-*;     // << insert YOUR api key and build header
$headers = array('Authorization: bearer '.$APItoken, 'Content-Type: application/json');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);     // <-- pass in the header with API Key
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");  // <-- GET Request, can also be POST,PUT or DELETE methods
$result = curl_exec($ch);
curl_close($ch);
echo $result;     // <-- see the result

require 'net/http'
require 'uri'

uri = URI.parse("https://www.yellowschedule.com/app/api/v2/services")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "bearer *-API Key-*"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

# response.code
# response.body

import requests

headers = {
    'Authorization': 'bearer *-API Key-*',
}

requests.get('https://www.yellowschedule.com/app/api/v2/services', headers=headers)

API Keys

When creating an API key it's a good idea to create your key with the minimal functionality that you require. For example if you only need the API for the ability to create appointments within YellowSchedule then you should create a key that only grants access to create appointments prevents access to all other functions. This is useful from a security perspective as tailoring the API key to suit your needs can help reduce the risk of exposure if there was a compromise of your system or API key. You can create as many keys as you like within YellowSchedule, with each key valid for only a single API function. You can still create just one key with access to all API functions. More on HTTP Methods/CRUD operations in YellowSchedule

Permission Examples

Live Example: Fetch Contacts

The following example includes a live API key (from a test account) to return the contacts. Note that the included API key in the request provided here only allows access for View ("GET") requests on Contacts (https://www.yellowschedule.com/app/api/v2/contacts) and trying to use this same API key for any other request will not work. As mentioned in the previous paragraph on API keys. You can use this same idea to control access to only what is required.

$ curl -H "Authorization: bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjp7ImNvbiI6InIifSwibSI6IjE2NDcxIiwidCI6MTQ4MDU5NzE5NCwiaWQiOjV9.9aExba9qw5rYr0b01dy01VezBJGb1pF-IsR9jSldO5Q" https://www.yellowschedule.com/app/api/v2/contacts -X GET

$url = "https://www.yellowschedule.com/app/api/v2/contacts";
$APItoken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjp7ImNvbiI6InIifSwibSI6IjE2NDcxIiwidCI6MTQ4MDU5NzE5NCwiaWQiOjV9.9aExba9qw5rYr0b01dy01VezBJGb1pF-IsR9jSldO5Q";
$headers = array('Authorization: bearer '.$APItoken, 'Content-Type: application/json');

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);     // <-- pass in the header with API Key
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
$result = curl_exec($ch);
curl_close($ch);
echo $result;     // <-- see the result

require 'net/http'
require 'uri'

uri = URI.parse("https://www.yellowschedule.com/app/api/v2/contacts")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjp7ImNvbiI6InIifSwibSI6IjE2NDcxIiwidCI6MTQ4MDU5NzE5NCwiaWQiOjV9.9aExba9qw5rYr0b01dy01VezBJGb1pF-IsR9jSldO5Q"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

# response.code
# response.body

import requests

headers = {
    'Authorization': 'bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjp7ImNvbiI6InIifSwibSI6IjE2NDcxIiwidCI6MTQ4MDU5NzE5NCwiaWQiOjV9.9aExba9qw5rYr0b01dy01VezBJGb1pF-IsR9jSldO5Q',
}

requests.get('https://www.yellowschedule.com/app/api/v2/contacts', headers=headers)

It should return JSON data containing a listing of the contacts on that test account.

{
	"contacts": [{
		"contact_id": *id*,
		"created_utc": "2016-01-15 12:45:56",
		"edited_utc": "2016-01-15 13:00:00",
		"firstname": "john",
		"lastname": "doe",
		"email": "test1@test.com",
		"cellphone": "123456789",
		"dob": "2000-12-25",
		"notes": "Some simple notes for the contact.. all contact data is encrypted in transfer and at rest!"
	}]
}

(You may notice the JSON returned in this example also includes "user_defined_data_fields" and "paginginfo" sections, more on this later)

Errors

HTTP response codes indicate the success or failure of an API request. In general, codes in the 2xx range indicate success, codes in the 4xx range indicate an error that failed given the information provided (e.g. incorrect authentication, or validation error). Codes in the 5xx range indicate an error on our end. (If you discover an error in the 5xx range, we would appreciate a quick note regarding how you came across the problem).

Note: All errors contain a description of the error, eg: HTTP 401 {"error":"invalid token or token was revoked or changed"}

HTTP Methods (CRUD Operations)

The Yellow Schedule API follows RESTful conventions using standard HTTP methods to perform Create, Read, Update, and Delete (CRUD) operations.

Available API Endpoints

Pagination

Pagination Response

All paginated endpoints include a paginginfo object in the response:

Returns of large data sets may be broken into pages. To navigate through large data sets the same function can be called again with a parameter for "page" being passed, for example page=2.

Any functions containing pagination will have a "paginginfo" section at the end of the JSON response data explaining:

• Number of pages
• Current page
• Page size
• Total page count
• Total record count

The example below is showing a return of record 1-100 in a list of a total of 127 results. This "paginginfo" is returned with the JSON response from the server. To get the 101-127 range the API call can be repeated with parameter page=2 sent. See the section below on passing parameters to the API to learn how to do this.

.......,
"paginginfo": {
	"result": "records found",
	"this_page": 1,
	"record_start_count": 1,
	"record_end_count": 100,
	"total_record_count": 127,
	"page_size": 100,
	"page_count": 1,
	"developer_notes": "Pagesize for this recordset is '100' if the full recordset is not being returned pass in parameter 'page=2' to view the next page"
}

Example: Fetching Multiple Pages

# First page (implicit page=1)
curl "https://www.yellowschedule.com/app/api/v2/contacts" \
  -H "Authorization: bearer YOUR_API_KEY"

# Second page
curl "https://www.yellowschedule.com/app/api/v2/contacts?page=2" \
  -H "Authorization: bearer YOUR_API_KEY"

$page = 1;
$allContacts = [];

do {
    $url = "https://www.yellowschedule.com/app/api/v2/contacts?page=" . $page;
    $response = /* ... make API call ... */;
    $data = json_decode($response, true);

    $allContacts = array_merge($allContacts, $data['contacts']);
    $page++;
} while ($page <= $data['paginginfo']['page_count']);

Passing Parameters to the API

Parameters are passed differently depending on the HTTP method:

There are currently two ways to pass parameters into the API. Through a query string in the URL (for GET and DELETE methods) or Posted through the body as a JSON object (POST and PUT methods).

See examples below for passing params in both GET and POST requests:

1. A fetch (GET) is requested on all appointments between a start (range_start) and end point (range_end). (2016-11-29 09:30:00 - 2016-12-02 17:45:00) and for a particular user (user with id:usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY) on the account. Parameters are passed in for "range_start", "range_end" and "user_id".

2. A (POST) is submitted to create an appointment on (2016-11-29 09:30:00 - 2016-11-29 10:00:00) for a particular user (user with id:usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY) with a title (title:initial consultation 30 minutes) on the account. Parameters are passed in for "start", "end", "title" and "user_id".

These parameters will be validated on our end before the request can be satisfied. If a parameter, such as a date, is entered incorrectly, it will result in a 422 validation error code. The details of the error should explain the date format required. More on error codes.

Params passed through url (GET and DELETE Methods)

$ curl -G -H "Authorization: bearer *-API Key-*" --data-urlencode "range_start=2016-11-29 09:30:00" --data-urlencode "range_end=2016-12-02 17:45:00" --data-urlencode "user_id=usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY" https://www.yellowschedule.com/app/api/v2/appointments -X GET

$url = "https://www.yellowschedule.com/app/api/v2/appointments";
$APItoken = "*-API Key-*";
$headers = array('Authorization: bearer '.$APItoken, 'Content-Type: application/json');

$fields = array(
	"range_start"=>"2016-11-29 09:30:00",
	"range_end"=>"2016-12-02 17:45:00",
	"user_id"=>"usr_90TQMB3TBB1U3gFM4hERzN1L2JEe0tCb"
);
$url .= "?".http_build_query($fields);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
$result = curl_exec($ch);
curl_close($ch);
echo $result;     // <-- see the result

require 'net/http'
require 'uri'

uri = URI.parse("https://www.yellowschedule.com/app/api/v2/appointments")
fields = { :range_start => '2016-11-29 09:30:00', :range_end => '2016-12-02 17:45:00', :user_id => 'usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY' }
uri.query = URI.encode_www_form(fields)
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "bearer *-API Key-*"

response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
  http.request(request)
end

# response.code
# response.body

import requests

headers = {
    'Authorization': 'bearer *-API Key-*',
}

fields = (
    ('range_start', '2016-11-29 09:30:00'),
    ('range_end', '2016-12-02 17:45:00'),
    ('user_id', 'usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY'),
)

requests.get('https://www.yellowschedule.com/app/api/v2/appointments', headers=headers, params=fields)

Params posted through Body (POST and PUT Methods)

$ curl -H "Authorization: bearer *-API Key-*" https://www.yellowschedule.com/app/api/v2/appointments -d "{\"start\":\"2016-11-29 09:30:00\",\"end\":\"2016-11-29 10:00:00\",\"title\":\"initial consultation 30 minutes\",\"user_id\":\"usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY\"}" -X POST

$url = "https://www.yellowschedule.com/app/api/v2/appointments";
$APItoken = "*-API Key-*";
$headers = array('Authorization: bearer '.$APItoken, 'Content-Type: application/json');

$fields = array(
	"start"=>"2016-11-29 09:30:00",
	"end"=>"2016-11-29 10:00:00",
	"title"=>"initial consultation 30 minutes",
	"user_id"=>"usr_90TQMB3TBB1U3gFM4hERzN1L2JEe0tCb"
);
$jsonData = json_encode($fields);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_POSTFIELDS, $jsonData);
$result = curl_exec($ch);
curl_close($ch);
echo $result;     // <-- see the result

require 'net/http'
require 'uri'
require 'json'

uri = URI.parse("https://www.yellowschedule.com/app/api/v2/appointments")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "bearer *-API Key-*"
request.body = JSON.dump({
  "start" => "2016-11-29 09:30:00",
  "end" => "2016-11-29 10:00:00",
  "title" => "initial consultation 30 minutes",
  "user_id" => "usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY"
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

# response.code
# response.body

import requests

headers = {
    'Authorization': 'bearer *-API Key-*',
}

data = '{"start":"2016-11-29 09:30:00","end":"2016-11-29 10:00:00","title":"initial consultation 30 minutes","user_id":"usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY"}'

requests.post('https://www.yellowschedule.com/app/api/v2/appointments', headers=headers, params=data)

Webhooks

Webhooks can be enabled by going to "Settings" (top right menu) >> "Webhooks". You can use Webhooks to be programatically notified about changes on your YellowSchedule account (for example whenever an appointment changes). When enabling webhooks, you must provide an endpoint to receive the notification. You can also select the type of webhook events that you want to be notified about. Whenever an appointment or a contact is created, updated or deleted, your application can receive a HTTP POST describing the type of change. The following webhook types are currently supported:

Handling Webhooks

Retry Policy

If your endpoint doesn't return a 200 status code, Yellow Schedule will retry the webhook:

• Up to 15 retry attempts
• Exponential backoff between retries
• First retry after 1 minute, increasing exponentially

Responding to a webhook:

Your endpoint should return a 200 HTTP status code to indicate that the webhook was successfully received. Any other status code will indicate a failure in delivery of the webhook. In this case, YellowSchedule will try to resend the webhook. We'll try up to 15 times with an exponential backoff period.

To verify the authenticity of the webhook and for security reasons, the payload will only contain the ID of the contact or appointment that was changed. Sensitive data such as client or appointment data will never be sent in webhooks. Your application will need to be configured to use the API to retrieve the actual changes.

{
 "webhook_id":"ys_apt70a47393ce381a5f42",
 "webhook_created":1494422644,
 "type":"appointment.created",
 "appointment_id_list":
  [
   {"id":"apt_90TQnJjVwVET0RjcVR0YHF3YK9UY1MzN"},
   {"id":"apt_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM"}
  ],
 "livemode":true
}

Payload

Appointments

GET Retrieve Appointments

Function: Appointments (GET)

Description: You can either specifiy an appointment_id to view a specific appointment, or instead set a date range (range_start, range_end) for a list of appointments to be returned. You can limit returned appointments to a particular user's appointments also using the param "user_id".

Parameters

"GET on appointments" JSON response sample

{
	"appointments": [{
		"id": "apt_90TQnJjVwVET0RjcVR0YHF3YK9UY1MzN",
		"user_id": "usr_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM",
		"title": "a title, or service name",
		"service_id": "ser_90TUspnNlV2YKV3MsVkSMl2VxljW4V3a",
		"created": "16|10|26|18|18",
		"start": "16|10|27|7|00",
		"end": "16|10|27|7|30",
		"loc_id": "0",
		"note": "notes for the appointment?",
		"tz": "Europe\/Dublin",
		"color": "b04efc",
		"contact_count": "1",
		"contact_status": "confirmed"
	},{
		"id": ...
	}],
	"paginginfo": ...
}

Response

POST Create Appointment

Function: Appointments (POST)

Description: Create an appointment on YellowSchedule using the API.

Parameters

"POST on appointments" JSON response sample

{
	"status":"success",
	"created_appointment_id":"apt_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM"
}

Response

PUT Update Appointment

Function: Appointments (PUT)

Description: update an appointment on YellowSchedule using the API. Appointments can be updated sending only the param that you want to change. If you want to clear a specific field, send an empty string in the parameter.

Parameters

"PUT on appointment" JSON response sample

{
	"status":"success",
	"updated_appointment_id":"apt_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM"
}

Response

DELETE Delete Appointment

Function: Appointments (DELETE)

Description: Delete an appointment on YellowSchedule using the API.

Parameters

"DELETE on appointment" JSON response sample

{
	"status":"success",
	"deleted_appointment_id":"apt_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM"
}

Response

Available Slots

GET Get Available Slots

Function: Available Slots (GET)

Description: You can use the available slots API function to return the free (bookable) slots for a user. Instead of returning the appointments for a user, this function returns the free 'gaps' between appointments for that user.

You might choose to use this function as the first step in a custom appointment booking solution. Steps 2 and 3 would be creation of a contact and creation of an appointment with that contact. If you require online booking functionality check out our pre-built booking system first which can be included into your website with a few lines of code and should suit most use cases.

Parameters

"GET on availableSlots" JSON response sample

{
	"freeslots_by_user": [{
		"user_id": "usr_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM",
		"available_timeslots": ["16|12|12|9|00", "16|12|12|13|00", "16|12|13|14|00", "16|12|14|9|00", "16|12|14|11|00"]
	}, {
		"user_id": "usr_90TUn1maaJzMH90Rqp1M0IFMoVEUGRUb",
		"available_timeslots": ["16|12|12|10|00", "16|12|14|13|00"]
	}],
	"users": [{
		"id": "usr_90TU4BXMUV0T0ZHVNpVVDdWeN10VTRUM",
		"title": "User name1",
		"img": "https://www.yellowschedule.com/*url for profile image*"
	}, {
		"id": "usr_90TUn1maaJzMH90Rqp1M0IFMoVEUGRUb",
		"title": "User name2",
		"img": "https://www.yellowschedule.com/*url for profile image*"
	}]
}

Response

Contacts

GET Retrieve Contacts

Function: Contacts (GET)

Description: Shows listing of an individual contact or a list of contacts.

Parameters

"GET on contacts" JSON response sample

/* simple example - very little being stored for contact 85800000 */

{
	"contacts": [{
		"contact_id": "con_90TQycTbUpFRlFEduhXOrMFUyVkSOFHM",
		"created_utc": "2015-06-17 11:13:05",
		"edited_utc": null,
		"archived": 0,
		"firstname": "john",
		"lastname": "client"
	}],
	"paginginfo": ...
}

/* complex example - more data for contact 85800001 plus data contained
   in user-defined fields: "Policy number" and "Blood Type" */

{
	"contacts": [{
		"contact_id": "con_90TQEt0SyoWROp3VYNlWNNzSVFzSyVWW",
		"created_utc": "2016-06-20 20:31:22",
		"edited_utc": "2016-12-01 13:07:21",
		"archived": 0,
		"firstname": "clark",
		"lastname": "kent",
		"email": "clarkkent@test.com",
		"cellphone": "353879999999",
		"gender": "m",
		"dob": "2000-12-25",
		"notes": "open notes section for the client",
		"user_defined_fields": [{
			"field_id": 10,
			"field_title": "Policy number",
			"value": "5480001200"
		}, {
			"field_id": 20,
			"field_title": "Blood Type",
			"value": "AB-"
		}]
	}],
	"user_defined_data_fields": [{
		"datafield_id": "10",
		"datafield_title": "Policy number",
		"datafield_enabled": "0",
		"enabled_for_bookings": "0",
		"is_selectbox": "0"
	},{
		"datafield_id": "20",
		"datafield_title": "Blood Type",
		"datafield_enabled": "1",
		"enabled_for_bookings": "0",
		"is_selectbox": "1",
		"selectbox_values": {
			"100": "A+",
			"101": "A-",
			"102": "AB+",
			"103": "AB-"
		}
	}],
	"paginginfo": ...
}

Response

POST Create Contact

Function: Contacts (POST)

Description: Create a contact on YellowSchedule using the API.

Parameters

"POST on contacts" JSON response sample

{
	"status":"success",
	"created_contact_id":"con_90TUspnNlV2YKV3MsVkSMl2VxljW4V3a"
}

Response

Additional note for setting contacts with custom data values

If you need to create (POST) or update (PUT) contacts and also need to set a custom data field for the contact then you can reference the field using custom_xxxx (where xxxx is a numeric field id). You can find the correct field id within the App by going to "Settings" (top right menu) >> "Contacts data fields" >> then click "Edit" beside the desired field. In light grey text beside the field title you will see the field key. See the screenshot below for an example where the field id for the additional field is custom_1534.

PUT Update Contact

Function: Contacts (PUT)

Description: Update a contact on YellowSchedule using the API. Contacts can be updated sending only the param that you want to change. If you want to clear a specific field, send an empty string in the parameter.

Parameters

"PUT on contacts" JSON response sample

{
	"status":"success",
	"updated_contact_id":"con_90TUspnNlV2YKV3MsVkSMl2VxljW4V3a"
}

Response

DELETE Delete Contact

Function: Contacts (DELETE)

Description: Delete a contact on YellowSchedule using the API.

Parameters

"DELETE on contacts" JSON response sample

{
	"status":"success",
	"deleted_contact_id":"con_90TUspnNlV2YKV3MsVkSMl2VxljW4V3a"
}

Response

Services

GET List Services

Function: Services (GET)

Description: Shows listing of services. When appointments are created a service can be set. Services are user defined and may be something like "Initial consultation" or "x-ray" for example. A price and time length can be set for the service when it's created allowing for easily scheduling of services and payment of services (if client payments are used). At present there is only GET method available to view services and services currently need to be created/edited/deleted within the YellowSchedule Application.

Parameters

"GET on services" JSON response sample

[{
	"service_id": "ser_90TUspnNlV2YKV3MsVkSMl2VxljW4V3a",
	"title": "initial consultation 30 minutes",
	"shorttitle": "initial 30m",
	"length": "30",
	"price": "$100",
	"users_with_access_to_service":[
		{"user_id":"usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY"},
		{"user_id":"usr_90TUn1maaJzMH90Rqp1M0IFMoVEUGRUb", "restrictions":["mo|09:00:00-13:00:00","tu|09:00:00-13:00:00"]}
	]
},{
	"service_id": ...
}]

Response

"users_with_access_to_service":[{
	"user_id":"usr_90TUn1maaJzMH90Rqp1M0IFMoVEUGRUb",
	"restrictions":[
		"mo|09:00:00-13:00:00","tu|09:00:00-13:00:00"
	]}]

Users

GET List Users

Function: Users (GET)

Description: Shows listing of user (staff) details. Add/edit/delete operations on system users must be performed within YellowSchedule at present.

Parameters

"GET on users" JSON response sample

[{
	"user_id": "usr_90zdhlGRJtCSxJkVEV2TYNzNxl1UrkmY",
	"created_utc": "2015-07-14 15:24:23",
	"firstname": "John",
	"lastname": "Doe",
	"username": "johndoe",
	"display_name": "Dr. John Doe",
	"email": "johndoe@johndoe.com",
	"img": "https://www.yellowschedule.com/*url for profile image*",
	"admin": "1",
	"access_all_contacts": "1",
	"access_all_msgs": "1",
	"booking_enabled": "1"
},{
	"user_id":...
}]

Response