Introduction

Base URL: https://api.getdentalray.com

This documentation aims to provide all the information you need to work with our API.

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

You can retrieve your token by submitting the correct login information in the Login Endpoint.

Auth Multi-Factor Management

APIs for doing two factor authentication with Twilio

Get MFA Settings

This endpoint lets you get mfa settings

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/auth/mfa/settings" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/auth/mfa/settings"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/auth/mfa/settings',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/mfa/settings'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Send OTP

requires authentication

This API will send OTP to the User currently in Session

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/auth/mfa/sms" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/auth/mfa/sms"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/auth/mfa/sms',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/mfa/sms'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Verify OTP

requires authentication

This endpoint lets you verify the OTP from Twilio

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/auth/mfa/verify" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"code\": \"dolor\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/auth/mfa/verify"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "code": "dolor"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/auth/mfa/verify',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'code' => 'dolor',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/mfa/verify'
payload = {
    "code": "dolor"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/auth/mfa/verify

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

code string

Example: dolor

Category Management

APIs for managing Categories

Get all Categories

requires authentication

This endpoint lets you get all the Categories

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/category" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/category"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/category',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/category'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a Category

requires authentication

This endpoint lets you store a new Category

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/category" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/category"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/category',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/category'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Show a Category

requires authentication

This endpoint lets you get a Category

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/category/{slug}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

slug string

The slug of the category. Example: magnam-error-saepe-temporibus-id-fugiat

Update a Category

requires authentication

This endpoint lets you update a single Category

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

PUT api/category/{slug}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

slug string

The slug of the category. Example: magnam-error-saepe-temporibus-id-fugiat

Delete a Category

requires authentication

This endpoint lets you delete a single Category

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/category/magnam-error-saepe-temporibus-id-fugiat'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/category/{slug}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

slug string

The slug of the category. Example: magnam-error-saepe-temporibus-id-fugiat

Dicom Management

API for managing dicom (worklists, media, patient) information.

Store Dicom

requires authentication

Create worklists, media, and patient according to the parameters.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/dicom" \
    --header "Authorization: bearer: {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"studyInstanceUID\": \"occaecati\",
    \"sopInstanceUID\": \"atque\",
    \"studyDate\": \"2023-03-27T09:56:54\",
    \"manufacturer\": \"suscipit\",
    \"manufacturerModelName\": \"saepe\",
    \"manufacturerModelVersion\": \"adipisci\",
    \"patientId\": \"minima\",
    \"patientName\": \"architecto\",
    \"patientBirthDate\": \"2023-03-27T09:56:54\",
    \"patientSex\": \"nihil\",
    \"acquisitionDateTime\": \"2023-03-27T09:56:54\",
    \"modality\": \"non\",
    \"institutionName\": \"cumque\",
    \"institutionAddress\": \"adipisci\",
    \"referringPhysicianName\": \"maxime\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/dicom"
);

const headers = {
    "Authorization": "bearer: {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "studyInstanceUID": "occaecati",
    "sopInstanceUID": "atque",
    "studyDate": "2023-03-27T09:56:54",
    "manufacturer": "suscipit",
    "manufacturerModelName": "saepe",
    "manufacturerModelVersion": "adipisci",
    "patientId": "minima",
    "patientName": "architecto",
    "patientBirthDate": "2023-03-27T09:56:54",
    "patientSex": "nihil",
    "acquisitionDateTime": "2023-03-27T09:56:54",
    "modality": "non",
    "institutionName": "cumque",
    "institutionAddress": "adipisci",
    "referringPhysicianName": "maxime"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/dicom',
    [
        'headers' => [
            'Authorization' => 'bearer: {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'studyInstanceUID' => 'occaecati',
            'sopInstanceUID' => 'atque',
            'studyDate' => '2023-03-27T09:56:54',
            'manufacturer' => 'suscipit',
            'manufacturerModelName' => 'saepe',
            'manufacturerModelVersion' => 'adipisci',
            'patientId' => 'minima',
            'patientName' => 'architecto',
            'patientBirthDate' => '2023-03-27T09:56:54',
            'patientSex' => 'nihil',
            'acquisitionDateTime' => '2023-03-27T09:56:54',
            'modality' => 'non',
            'institutionName' => 'cumque',
            'institutionAddress' => 'adipisci',
            'referringPhysicianName' => 'maxime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/dicom'
payload = {
    "studyInstanceUID": "occaecati",
    "sopInstanceUID": "atque",
    "studyDate": "2023-03-27T09:56:54",
    "manufacturer": "suscipit",
    "manufacturerModelName": "saepe",
    "manufacturerModelVersion": "adipisci",
    "patientId": "minima",
    "patientName": "architecto",
    "patientBirthDate": "2023-03-27T09:56:54",
    "patientSex": "nihil",
    "acquisitionDateTime": "2023-03-27T09:56:54",
    "modality": "non",
    "institutionName": "cumque",
    "institutionAddress": "adipisci",
    "referringPhysicianName": "maxime"
}
headers = {
  'Authorization': 'bearer: {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/dicom

Headers

Authorization

Example: bearer: {token}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

path string optional

link string optional

studyInstanceUID string

Example: occaecati

sopInstanceUID string

Example: atque

studyDate string optional

Must be a valid date. Example: 2023-03-27T09:56:54

manufacturer string

Example: suscipit

manufacturerModelName string optional

Example: saepe

manufacturerModelVersion string optional

Example: adipisci

patientId string

Example: minima

patientName string

Example: architecto

patientBirthDate string optional

Must be a valid date. Example: 2023-03-27T09:56:54

patientSex string optional

Example: nihil

acquisitionDateTime string optional

Must be a valid date. Example: 2023-03-27T09:56:54

modality string

Example: non

institutionName string optional

Example: cumque

institutionAddress string optional

Example: adipisci

referringPhysicianName string optional

Example: maxime

Update Dicom

requires authentication

Update worklist, media and patient according to the paramters where id matches worklist.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/dicom/74" \
    --header "Authorization: bearer: {token}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"studyDate\": \"2023-03-27T09:56:54\",
    \"patientId\": \"maxime\",
    \"patientName\": \"sed\",
    \"patientBirthDate\": \"2023-03-27T09:56:54\",
    \"patientSex\": \"molestiae\",
    \"status\": \"corrupti\",
    \"scan_status\": \"assumenda\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/dicom/74"
);

const headers = {
    "Authorization": "bearer: {token}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "studyDate": "2023-03-27T09:56:54",
    "patientId": "maxime",
    "patientName": "sed",
    "patientBirthDate": "2023-03-27T09:56:54",
    "patientSex": "molestiae",
    "status": "corrupti",
    "scan_status": "assumenda"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/dicom/74',
    [
        'headers' => [
            'Authorization' => 'bearer: {token}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'studyDate' => '2023-03-27T09:56:54',
            'patientId' => 'maxime',
            'patientName' => 'sed',
            'patientBirthDate' => '2023-03-27T09:56:54',
            'patientSex' => 'molestiae',
            'status' => 'corrupti',
            'scan_status' => 'assumenda',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/dicom/74'
payload = {
    "studyDate": "2023-03-27T09:56:54",
    "patientId": "maxime",
    "patientName": "sed",
    "patientBirthDate": "2023-03-27T09:56:54",
    "patientSex": "molestiae",
    "status": "corrupti",
    "scan_status": "assumenda"
}
headers = {
  'Authorization': 'bearer: {token}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/dicom/{worklist_id}

Headers

Authorization

Example: bearer: {token}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

worklist_id integer

The ID of the worklist. Example: 74

Body Parameters

path string optional

link string optional

studyDate string optional

Must be a valid date. Example: 2023-03-27T09:56:54

patientId string optional

Example: maxime

patientName string optional

Example: sed

patientBirthDate string optional

Must be a valid date. Example: 2023-03-27T09:56:54

patientSex string optional

Example: molestiae

status string optional

Example: corrupti

scan_status string optional

Example: assumenda

Endpoints

Authenticate the request for channel access.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/broadcasting/auth" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/broadcasting/auth"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/broadcasting/auth',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/broadcasting/auth'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store User Heartbeat

requires authentication

This endpoint lets you store the last sync details from the user

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/heartbeat" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"version\": \"accusamus\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/heartbeat"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "version": "accusamus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/heartbeat',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'version' => 'accusamus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/heartbeat'
payload = {
    "version": "accusamus"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/heartbeat

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

version string

Example: accusamus

Form Management

All Forms

Display a listing of the resource.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/form" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/form"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/form',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/form'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Form

Store a newly created resource in storage.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/form" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/form"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/form',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/form'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Show Form

Display the specified resource matching the given id.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/form/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/form/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/form/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/form/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Media Management

APIs for managing Media

Get all Media

requires authentication

This endpoint lets you get all the Media

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/media" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/media"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/media',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/media'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a Media

requires authentication

This endpoint lets you store a new Media

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/media" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "s3_object=voluptatum" \
    --form "status=assumenda" \
    --form "description=Quia quis ab incidunt aut accusantium officia nisi." \
    --form "meta[is_dicom]=1" \
    --form "file=@/tmp/phprHndDg"

const url = new URL(
    "https://api.getdentalray.com/api/media"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('s3_object', 'voluptatum');
body.append('status', 'assumenda');
body.append('description', 'Quia quis ab incidunt aut accusantium officia nisi.');
body.append('meta[is_dicom]', '1');
body.append('file', document.querySelector('input[name="file"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/media',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 's3_object',
                'contents' => 'voluptatum'
            ],
            [
                'name' => 'status',
                'contents' => 'assumenda'
            ],
            [
                'name' => 'description',
                'contents' => 'Quia quis ab incidunt aut accusantium officia nisi.'
            ],
            [
                'name' => 'meta[is_dicom]',
                'contents' => '1'
            ],
            [
                'name' => 'file',
                'contents' => fopen('/tmp/phprHndDg', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/media'
files = {
  'file': open('/tmp/phprHndDg', 'rb')
}
payload = {
    "s3_object": "voluptatum",
    "status": "assumenda",
    "description": "Quia quis ab incidunt aut accusantium officia nisi.",
    "meta": {
        "is_dicom": true
    }
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, files=files, data=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/media

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: multipart/form-data

Accept

Example: application/json

Body Parameters

file file optional

Must be a file. Example: /tmp/phprHndDg

s3_object string optional

Example: voluptatum

s3_objects object optional

Must have at least 1 items.

status string optional

Example: assumenda

description string optional

Example: Quia quis ab incidunt aut accusantium officia nisi.

meta object optional

is_dicom boolean optional true false

Example: true

patient_id string optional

patient_name string optional

patient_dob string optional

patient_gender string optional

Show a Media

requires authentication

This endpoint lets you get a Media

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/media/401" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/media/401"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/media/401',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/media/401'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/media/{media_id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

media_id integer

The ID of the media. Example: 401

Update a Media

requires authentication

This endpoint lets you update a Media File matching the provided ID.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/media/401" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/media/401"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/media/401',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/media/401'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

PUT api/media/{media_id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

media_id integer

The ID of the media. Example: 401

Delete a Media

requires authentication

This endpoint lets you delete a single Role

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/media/401" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/media/401"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/media/401',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/media/401'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/media/{media_id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

media_id integer

The ID of the media. Example: 401

Download Media

requires authentication

This endpoint lets you download a single Media file that matches the ID Request Query.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/media/401/download" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/media/401/download"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/media/401/download',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/media/401/download'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/media/{media_id}/download

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

media_id integer

The ID of the media. Example: 401

Office Management

APIs for managing Offices

Get all Offices

requires authentication

This endpoint lets you get all Offices

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/office" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/office"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/office',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

GET api/office/form-office

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/office/form-office" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/office/form-office"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/office/form-office',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office/form-office'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

GET api/office/form-dentists

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/office/form-dentists" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/office/form-dentists"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/office/form-dentists',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office/form-dentists'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Office

requires authentication

This endpoint lets you add a new Office

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/office" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"necessitatibus\",
    \"address_line_1\": \"ea\",
    \"city\": \"sed\",
    \"state\": \"voluptatem\",
    \"zipcode\": \"aut\",
    \"primary_contact_name\": \"repudiandae\",
    \"primary_contact_email\": \"chyna.botsford@example.org\",
    \"practice_management_software\": \"maxime\",
    \"cbct_make_and_model\": \"quae\",
    \"image_viewing_software\": \"recusandae\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/office"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "necessitatibus",
    "address_line_1": "ea",
    "city": "sed",
    "state": "voluptatem",
    "zipcode": "aut",
    "primary_contact_name": "repudiandae",
    "primary_contact_email": "chyna.botsford@example.org",
    "practice_management_software": "maxime",
    "cbct_make_and_model": "quae",
    "image_viewing_software": "recusandae"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/office',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'necessitatibus',
            'address_line_1' => 'ea',
            'city' => 'sed',
            'state' => 'voluptatem',
            'zipcode' => 'aut',
            'primary_contact_name' => 'repudiandae',
            'primary_contact_email' => 'chyna.botsford@example.org',
            'practice_management_software' => 'maxime',
            'cbct_make_and_model' => 'quae',
            'image_viewing_software' => 'recusandae',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office'
payload = {
    "name": "necessitatibus",
    "address_line_1": "ea",
    "city": "sed",
    "state": "voluptatem",
    "zipcode": "aut",
    "primary_contact_name": "repudiandae",
    "primary_contact_email": "chyna.botsford@example.org",
    "practice_management_software": "maxime",
    "cbct_make_and_model": "quae",
    "image_viewing_software": "recusandae"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/office

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

name string

Example: necessitatibus

address_line_1 string

Example: ea

city string

Example: sed

state string

Example: voluptatem

zipcode string

Example: aut

primary_contact_name string

Example: repudiandae

primary_contact_email string

Must be a valid email address. Example: chyna.botsford@example.org

practice_management_software string optional

Example: maxime

cbct_make_and_model string optional

Example: quae

image_viewing_software string optional

Example: recusandae

Show Office

requires authentication

This endpoit lets you get a single Office that matched with the id.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/office/14" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/office/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/office/14',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office/14'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/office/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the office. Example: 14

Update Office

requires authentication

This endpoint lets you get a single Office that matches with the id.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/office/14" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"similique\",
    \"address_line_1\": \"itaque\",
    \"address_line_2\": \"rerum\",
    \"city\": \"cum\",
    \"state\": \"ipsum\",
    \"zipcode\": \"dolorem\",
    \"primary_contact_name\": \"consequatur\",
    \"primary_contact_email\": \"weissnat.maritza@example.net\",
    \"practice_management_software\": \"architecto\",
    \"cbct_make_and_model\": \"a\",
    \"image_viewing_software\": \"deserunt\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/office/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "similique",
    "address_line_1": "itaque",
    "address_line_2": "rerum",
    "city": "cum",
    "state": "ipsum",
    "zipcode": "dolorem",
    "primary_contact_name": "consequatur",
    "primary_contact_email": "weissnat.maritza@example.net",
    "practice_management_software": "architecto",
    "cbct_make_and_model": "a",
    "image_viewing_software": "deserunt"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/office/14',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'similique',
            'address_line_1' => 'itaque',
            'address_line_2' => 'rerum',
            'city' => 'cum',
            'state' => 'ipsum',
            'zipcode' => 'dolorem',
            'primary_contact_name' => 'consequatur',
            'primary_contact_email' => 'weissnat.maritza@example.net',
            'practice_management_software' => 'architecto',
            'cbct_make_and_model' => 'a',
            'image_viewing_software' => 'deserunt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office/14'
payload = {
    "name": "similique",
    "address_line_1": "itaque",
    "address_line_2": "rerum",
    "city": "cum",
    "state": "ipsum",
    "zipcode": "dolorem",
    "primary_contact_name": "consequatur",
    "primary_contact_email": "weissnat.maritza@example.net",
    "practice_management_software": "architecto",
    "cbct_make_and_model": "a",
    "image_viewing_software": "deserunt"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/office/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the office. Example: 14

Body Parameters

name string

Example: similique

address_line_1 string

Example: itaque

address_line_2 string optional

Example: rerum

city string

Example: cum

state string

Example: ipsum

zipcode string

Example: dolorem

primary_contact_name string

Example: consequatur

primary_contact_email string

Must be a valid email address. Example: weissnat.maritza@example.net

practice_management_software string optional

Example: architecto

cbct_make_and_model string optional

Example: a

image_viewing_software string optional

Example: deserunt

Destroy Office

requires authentication

This endpoint lets you destroy a single Office resource that matches with the id

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/office/14" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/office/14"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/office/14',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/office/14'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/office/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the office. Example: 14

Options Management

APIs for managing Options

Get All Options

requires authentication

This endpoint lets you get all autoloaded options

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/option" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/option"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/option',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/option'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Option

requires authentication

This endpoint lets you add a new option

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/option" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"et\",
    \"value\": \"sit\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/option"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "et",
    "value": "sit"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/option',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'et',
            'value' => 'sit',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/option'
payload = {
    "name": "et",
    "value": "sit"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/option

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

name string

Example: et

value string

Example: sit

Show Option

requires authentication

This endpoint lets you get a single option that matches the name.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/option/non" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/option/non"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/option/non',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/option/non'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/option/{name}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

name string

Example: non

Update Option

requires authentication

This endpoint lets you update a single option that matches the neme.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/option/eveniet" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"value\": \"aut\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/option/eveniet"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "value": "aut"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/option/eveniet',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'value' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/option/eveniet'
payload = {
    "value": "aut"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/option/{name}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

name string

Example: eveniet

Body Parameters

value string

Example: aut

Destroy Option

requires authentication

This endpoint lets you delete a single option that matches the name.

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/option/consectetur" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/option/consectetur"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/option/consectetur',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/option/consectetur'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/option/{name}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

name string

Example: consectetur

Organization Management

APIs for managing Organizations

Get all Organizations

requires authentication

This endpoint lets you get all Organizations

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/organization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/organization"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/organization',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/organization'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Organization

requires authentication

This endpoint lets you add a new Organization

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/organization" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"organization_administrator_id\": 809074388.83513,
    \"slug\": \"itaque\",
    \"name\": \"facilis\",
    \"description\": \"Vero ab nisi cum aut nemo molestias rem.\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/organization"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "organization_administrator_id": 809074388.83513,
    "slug": "itaque",
    "name": "facilis",
    "description": "Vero ab nisi cum aut nemo molestias rem."
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/organization',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'organization_administrator_id' => 809074388.83513,
            'slug' => 'itaque',
            'name' => 'facilis',
            'description' => 'Vero ab nisi cum aut nemo molestias rem.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/organization'
payload = {
    "organization_administrator_id": 809074388.83513,
    "slug": "itaque",
    "name": "facilis",
    "description": "Vero ab nisi cum aut nemo molestias rem."
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/organization

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

organization_administrator_id number

Example: 809074388.83513

slug string

Example: itaque

name string

Example: facilis

description string optional

Example: Vero ab nisi cum aut nemo molestias rem.

Show Organization

requires authentication

This endpoit lets you get a single Organization that matched with the id.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/organization/4" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/organization/4"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/organization/4',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/organization/4'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/organization/{office}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

office integer

Example: 4

Update Organization

requires authentication

This endpoint lets you get a single Organization that matches with the id.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/organization/6" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"organization_administrator_id\": 21.695096,
    \"slug\": \"neque\",
    \"name\": \"aliquam\",
    \"description\": \"Et dolores qui ut et assumenda quidem.\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/organization/6"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "organization_administrator_id": 21.695096,
    "slug": "neque",
    "name": "aliquam",
    "description": "Et dolores qui ut et assumenda quidem."
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/organization/6',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'organization_administrator_id' => 21.695096,
            'slug' => 'neque',
            'name' => 'aliquam',
            'description' => 'Et dolores qui ut et assumenda quidem.',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/organization/6'
payload = {
    "organization_administrator_id": 21.695096,
    "slug": "neque",
    "name": "aliquam",
    "description": "Et dolores qui ut et assumenda quidem."
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/organization/{office}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

office integer

Example: 6

Body Parameters

organization_administrator_id number

Example: 21.695096

slug string

Example: neque

name string

Example: aliquam

description string optional

Example: Et dolores qui ut et assumenda quidem.

Destroy Organization

requires authentication

This endpoint lets you destroy a single Organization resource that matches with the id

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/organization/8" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/organization/8"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/organization/8',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/organization/8'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/organization/{office}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

office integer

Example: 8

Patient Management

All Patients

Display a listing of the resource.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/patient" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/patient',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Display Patient

Display only patients not existing on reports table

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/patient/form-patient-list" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient/form-patient-list"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/patient/form-patient-list',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient/form-patient-list'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Get Patient List

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/patient/patient-list" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient/patient-list"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/patient/patient-list',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient/patient-list'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Live Search

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/patient/patient-live" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient/patient-live"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/patient/patient-live',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient/patient-live'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Patient

Store a newly created resource in storage.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/patient" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/patient',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Show Patient

Display the specified resource matching the given resource id.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/patient/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/patient/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update Patient Update the specified resource in storage.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/patient/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/patient/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()

Received response:

Request failed with error:

Delete Patient

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/patient/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/patient/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/patient/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/patient/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Permission Management

Get all Permissions

requires authentication

This endpoint returns all the permissions available in the system.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/permission" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/permission"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/permission',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/permission'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Personal Access Token Management

User Tokens

Get all of the personal access tokens for the authenticated user.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/oauth/personal-access-token" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/oauth/personal-access-token"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/oauth/personal-access-token',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/oauth/personal-access-token'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Create Token

Create a new personal access token for the user.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/oauth/personal-access-token" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"bprsxulvntiznxpj\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/oauth/personal-access-token"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "bprsxulvntiznxpj"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/oauth/personal-access-token',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'bprsxulvntiznxpj',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/oauth/personal-access-token'
payload = {
    "name": "bprsxulvntiznxpj"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/oauth/personal-access-token

Headers

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

name string

Must not be greater than 191 characters. Example: bprsxulvntiznxpj

scopes object optional

Must be one of user.index, user.store, user.show, user.update, user.destroy, role.index, role.show, role.store, role.update, role.destroy, user.role.show, user.role.store, user.role.update, user.role.destroy, user.permission.store, user.permission.show, user.permission.destroy, user.meta.index, user.meta.store, user.meta.show, user.meta.update, user.meta.destroy, user.heartbeat.store, category.index, category.store, category.show, category.update, category.destroy, option.index, option.store, option.show, option.update, option.destroy, media.index, media.store, media.show, media.update, media.destroy, media.download, report.index, report.store, report.show, report.update, report.destroy, report.preview, office.index, office.store, office.show, office.update, office.destroy, worklist.index, worklist.store, worklist.show, worklist.update, worklist.destroy, organization.index, organization.store, organization.show, organization.update, organization.destroy, radiologist.index, radiologist.store, radiologist.show, radiologist.update, radiologist.destroy, dicom.index, dicom.store, dicom.show, dicom.update, or dicom.destroy.

Delete Token

Delete the given token.

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/oauth/personal-access-token/sunt" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/oauth/personal-access-token/sunt"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/oauth/personal-access-token/sunt',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/oauth/personal-access-token/sunt'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Radiologist Management

APIs for managing Radiologist Resources

All Radiologist

requires authentication

This endpoint lets you get all Radiologist Resources.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/radiologist" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/radiologist"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/radiologist',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/radiologist'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Report Management

This endpoint lets you store a new report

All Report This endpoint lets you get all reports

requires authentication

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/report" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/report"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/report',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/report'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Report

requires authentication

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/report" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"form_id\": 662.486845,
    \"office_id\": 50,
    \"worklist_id\": 21.2531359,
    \"patient_first_name\": \"smvedklwtsvej\",
    \"patient_last_name\": \"tdhnyttfaz\",
    \"patient_dob\": \"ex\",
    \"body\": \"omnis\",
    \"exam\": \"laborum\",
    \"indication\": \"voluptatem\",
    \"technique\": \"quo\",
    \"comparison\": \"quis\",
    \"osseous_structures\": \"qui\",
    \"paranasal_sinuses\": \"sint\",
    \"salivary_glands\": \"veritatis\",
    \"oral_cavity_pharynx\": \"animi\",
    \"other_areas\": \"dolores\",
    \"additional_notes\": \"exercitationem\",
    \"impression\": \"corrupti\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/report"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "form_id": 662.486845,
    "office_id": 50,
    "worklist_id": 21.2531359,
    "patient_first_name": "smvedklwtsvej",
    "patient_last_name": "tdhnyttfaz",
    "patient_dob": "ex",
    "body": "omnis",
    "exam": "laborum",
    "indication": "voluptatem",
    "technique": "quo",
    "comparison": "quis",
    "osseous_structures": "qui",
    "paranasal_sinuses": "sint",
    "salivary_glands": "veritatis",
    "oral_cavity_pharynx": "animi",
    "other_areas": "dolores",
    "additional_notes": "exercitationem",
    "impression": "corrupti"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/report',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'form_id' => 662.486845,
            'office_id' => 50.0,
            'worklist_id' => 21.2531359,
            'patient_first_name' => 'smvedklwtsvej',
            'patient_last_name' => 'tdhnyttfaz',
            'patient_dob' => 'ex',
            'body' => 'omnis',
            'exam' => 'laborum',
            'indication' => 'voluptatem',
            'technique' => 'quo',
            'comparison' => 'quis',
            'osseous_structures' => 'qui',
            'paranasal_sinuses' => 'sint',
            'salivary_glands' => 'veritatis',
            'oral_cavity_pharynx' => 'animi',
            'other_areas' => 'dolores',
            'additional_notes' => 'exercitationem',
            'impression' => 'corrupti',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/report'
payload = {
    "form_id": 662.486845,
    "office_id": 50,
    "worklist_id": 21.2531359,
    "patient_first_name": "smvedklwtsvej",
    "patient_last_name": "tdhnyttfaz",
    "patient_dob": "ex",
    "body": "omnis",
    "exam": "laborum",
    "indication": "voluptatem",
    "technique": "quo",
    "comparison": "quis",
    "osseous_structures": "qui",
    "paranasal_sinuses": "sint",
    "salivary_glands": "veritatis",
    "oral_cavity_pharynx": "animi",
    "other_areas": "dolores",
    "additional_notes": "exercitationem",
    "impression": "corrupti"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/report

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

form_id number

Example: 662.486845

office_id number

Example: 50

worklist_id number optional

Example: 21.2531359

patient_first_name string optional

Must not be greater than 255 characters. Example: smvedklwtsvej

patient_last_name string optional

Must not be greater than 255 characters. Example: tdhnyttfaz

patient_dob string optional

Example: ex

body string optional

Example: omnis

exam string optional

Example: laborum

indication string optional

Example: voluptatem

technique string optional

Example: quo

comparison string optional

Example: quis

osseous_structures string optional

Example: qui

paranasal_sinuses string optional

Example: sint

salivary_glands string optional

Example: veritatis

oral_cavity_pharynx string optional

Example: animi

other_areas string optional

Example: dolores

additional_notes string optional

Example: exercitationem

impression string optional

Example: corrupti

Preview Report

requires authentication

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/report/preview" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/report/preview"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/report/preview',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/report/preview'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Show Report

requires authentication

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/report/42" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/report/42"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/report/42',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/report/42'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/report/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the report. Example: 42

Update Report

requires authentication

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/report/42" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/report/42"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/report/42',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/report/42'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

PUT api/report/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the report. Example: 42

Destroy Report

requires authentication

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/report/42" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/report/42"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/report/42',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/report/42'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/report/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the report. Example: 42

Role Management

APIs for managing Roles

Get all Roles

requires authentication

This endpoint lets you get all the Roles

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/role" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/role"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/role',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/role'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a Role

requires authentication

This endpoint lets you store a new Role

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/role" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"in\",
    \"slug\": \"ut\",
    \"permissions\": []
}"

const url = new URL(
    "https://api.getdentalray.com/api/role"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "in",
    "slug": "ut",
    "permissions": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/role',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'in',
            'slug' => 'ut',
            'permissions' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/role'
payload = {
    "name": "in",
    "slug": "ut",
    "permissions": []
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/role

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

name string

Example: in

slug string

Example: ut

permissions object

Show a Role

requires authentication

This endpoint lets you get a Role

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/role/administrator" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/role/administrator"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/role/administrator',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/role/administrator'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/role/{slug}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

slug string

The slug of the role. Example: administrator

Update a Role

requires authentication

This endpoint lets you update a single Role

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/role/administrator" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/role/administrator"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/role/administrator',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/role/administrator'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

PUT api/role/{slug}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

slug string

The slug of the role. Example: administrator

Delete a Role

requires authentication

This endpoint lets you delete a single Role

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/role/administrator" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/role/administrator"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/role/administrator',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/role/administrator'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/role/{slug}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

slug string

The slug of the role. Example: administrator

User Management

APIs for managnign Users

This endpoint allows you to login users.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/auth/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"username\": \"sbul\",
    \"password\": \"}cVG=LiVy54j4;exa\",
    \"timezone\": \"America\\/Chihuahua\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/auth/login"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "username": "sbul",
    "password": "}cVG=LiVy54j4;exa",
    "timezone": "America\/Chihuahua"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/auth/login',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'username' => 'sbul',
            'password' => '}cVG=LiVy54j4;exa',
            'timezone' => 'America/Chihuahua',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/login'
payload = {
    "username": "sbul",
    "password": "}cVG=LiVy54j4;exa",
    "timezone": "America\/Chihuahua"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/auth/login

Headers

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

username string

Must be at least 5 characters. Must not be greater than 255 characters. Example: sbul

password string

Must be at least 5 characters. Must not be greater than 255 characters. Example: }cVG=LiVy54j4;exa

timezone string optional

Example: America/Chihuahua

Register API

This endpoint allows you to register a new user.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/auth/register" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"username\": \"z\",
    \"email\": \"nienow.vincenzo@example.net\",
    \"password\": \"r?7-V&e]MCc[BrC\",
    \"first_name\": \"csv\",
    \"middle_name\": \"excepturi\",
    \"last_name\": \"yputfxfavr\",
    \"role\": \"sapiente\",
    \"activate\": true,
    \"phone_number\": 85.7,
    \"office_name\": \"oc\",
    \"office_address_line_1\": \"adtlsstgcrlvgjferhmo\",
    \"office_address_line_2\": \"avcz\",
    \"office_city\": \"bxxigrlpjylt\",
    \"office_state\": \"xrtccdlcgwhm\",
    \"office_zipcode\": \"btanhzltdtwarryhday\",
    \"school_diploma_id\": 4,
    \"residency_diploma_id\": 1,
    \"state_license_id\": 10,
    \"abr_file_id\": 6,
    \"medical_school_diploma_id\": 11
}"

const url = new URL(
    "https://api.getdentalray.com/api/auth/register"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "username": "z",
    "email": "nienow.vincenzo@example.net",
    "password": "r?7-V&e]MCc[BrC",
    "first_name": "csv",
    "middle_name": "excepturi",
    "last_name": "yputfxfavr",
    "role": "sapiente",
    "activate": true,
    "phone_number": 85.7,
    "office_name": "oc",
    "office_address_line_1": "adtlsstgcrlvgjferhmo",
    "office_address_line_2": "avcz",
    "office_city": "bxxigrlpjylt",
    "office_state": "xrtccdlcgwhm",
    "office_zipcode": "btanhzltdtwarryhday",
    "school_diploma_id": 4,
    "residency_diploma_id": 1,
    "state_license_id": 10,
    "abr_file_id": 6,
    "medical_school_diploma_id": 11
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/auth/register',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'username' => 'z',
            'email' => 'nienow.vincenzo@example.net',
            'password' => 'r?7-V&e]MCc[BrC',
            'first_name' => 'csv',
            'middle_name' => 'excepturi',
            'last_name' => 'yputfxfavr',
            'role' => 'sapiente',
            'activate' => true,
            'phone_number' => 85.7,
            'office_name' => 'oc',
            'office_address_line_1' => 'adtlsstgcrlvgjferhmo',
            'office_address_line_2' => 'avcz',
            'office_city' => 'bxxigrlpjylt',
            'office_state' => 'xrtccdlcgwhm',
            'office_zipcode' => 'btanhzltdtwarryhday',
            'school_diploma_id' => 4,
            'residency_diploma_id' => 1,
            'state_license_id' => 10,
            'abr_file_id' => 6,
            'medical_school_diploma_id' => 11,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/register'
payload = {
    "username": "z",
    "email": "nienow.vincenzo@example.net",
    "password": "r?7-V&e]MCc[BrC",
    "first_name": "csv",
    "middle_name": "excepturi",
    "last_name": "yputfxfavr",
    "role": "sapiente",
    "activate": true,
    "phone_number": 85.7,
    "office_name": "oc",
    "office_address_line_1": "adtlsstgcrlvgjferhmo",
    "office_address_line_2": "avcz",
    "office_city": "bxxigrlpjylt",
    "office_state": "xrtccdlcgwhm",
    "office_zipcode": "btanhzltdtwarryhday",
    "school_diploma_id": 4,
    "residency_diploma_id": 1,
    "state_license_id": 10,
    "abr_file_id": 6,
    "medical_school_diploma_id": 11
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/auth/register

Headers

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

username string

Must be at least 5 characters. Must not be greater than 255 characters. Example: z

email string

Must be a valid email address. Must be at least 10 characters. Must not be greater than 255 characters. Example: nienow.vincenzo@example.net

password string

Must be at least 8 characters. Must not be greater than 255 characters. Example: r?7-V&e]MCc[BrC

first_name string

Must be at least 3 characters. Must not be greater than 255 characters. Example: csv

middle_name string optional

Example: excepturi

last_name string

Must be at least 3 characters. Must not be greater than 255 characters. Example: yputfxfavr

role string optional

Example: sapiente

permissions object optional

activate boolean optional true false

Example: true

phone_number number optional

Example: 85.7

office_name string optional

This field is required when role is dentist. Must be at least 5 characters. Must not be greater than 255 characters. Example: oc

office_address_line_1 string optional

This field is required when role is dentist. Must be at least 5 characters. Must not be greater than 255 characters. Example: adtlsstgcrlvgjferhmo

office_address_line_2 string optional

This field is required when role is dentist. Must be at least 5 characters. Must not be greater than 255 characters. Example: avcz

office_city string optional

This field is required when role is dentist. Must be at least 2 characters. Must not be greater than 255 characters. Example: bxxigrlpjylt

office_state string optional

This field is required when role is dentist. Must be at least 2 characters. Must not be greater than 255 characters. Example: xrtccdlcgwhm

office_zipcode string optional

This field is required when role is dentist. Must be at least 5 characters. Must not be greater than 255 characters. Example: btanhzltdtwarryhday

birth_date string optional

This field is required when role is radiologist.

school_diploma_id integer optional

This field is required when role is radiologist. Example: 4

residency_diploma_id integer optional

This field is required when role is radiologist. Example: 1

state_license_id integer optional

This field is required when role is radiologist. Example: 10

abr_file_id integer optional

This field is required when role is radiologist. Example: 6

medical_school_diploma_id integer optional

This field is required when role is radiologist. Example: 11

Activate a User

requires authentication

This endpoint lets you activate a User.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/auth/activate" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"code\": \"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/auth/activate"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/auth/activate',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'code' => 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/activate'
payload = {
    "code": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/auth/activate

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

code string

The activation code. Example: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Forgot Password

This endpoint will send an authorized email reset password

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/auth/password/forgot" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"halvorson.thalia@example.net\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/auth/password/forgot"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "halvorson.thalia@example.net"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/auth/password/forgot',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'halvorson.thalia@example.net',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/password/forgot'
payload = {
    "email": "halvorson.thalia@example.net"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Reset Password

This endpoint lets you reset and update password

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/auth/password/reset" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password\": \"n\\\"C$(ll+.:~=0kaiJ;\",
    \"confirm_password\": \"libero\",
    \"token\": \"assumenda\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/auth/password/reset"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "password": "n\"C$(ll+.:~=0kaiJ;",
    "confirm_password": "libero",
    "token": "assumenda"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/auth/password/reset',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password' => 'n"C$(ll+.:~=0kaiJ;',
            'confirm_password' => 'libero',
            'token' => 'assumenda',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/password/reset'
payload = {
    "password": "n\"C$(ll+.:~=0kaiJ;",
    "confirm_password": "libero",
    "token": "assumenda"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/auth/password/reset

Headers

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

password string

Example: n"C$(ll+.:~=0kaiJ;

confirm_password string

Example: libero

token string

Example: assumenda

Me API

requires authentication

This endpoint will return the currently logged-in user.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/auth/me" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/auth/me"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/auth/me',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/me'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Logout API

This endpoint allows you to logout user.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/auth/logout" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/auth/logout"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/auth/logout',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/auth/logout'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Get all Users

requires authentication

This endpoint lets you get all Users.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user?search=illum&role=molestiae&includes[]=quibusdam" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \

const url = new URL(
    "https://api.getdentalray.com/api/user"
);

const params = {
    "search": "illum",
    "role": "molestiae",
    "includes[0]": "quibusdam",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'search' => 'illum',
            'role' => 'molestiae',
            'includes[0]' => 'quibusdam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user'
params = {
  'search': 'illum',
  'role': 'molestiae',
  'includes[0]': 'quibusdam',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/user

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Query Parameters

search string optional

string used to search from email, username, first_name, and last_name Example: illum

role string optional

used to filter results based on a specific role. Example: molestiae

includes string[] optional

an array of available data to include.

Body Parameters

includes object optional

Store User

requires authentication

This endpoint lets you create a new User.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"username\": \"lysgoeulraesciarjymovmu\",
    \"email\": \"miguel47@example.com\",
    \"password\": \"R\\/ub*E4l&Wa\",
    \"first_name\": \"veritatis\",
    \"last_name\": \"eos\",
    \"role\": \"quia\",
    \"activate\": false,
    \"phone_number\": 3293.6102143,
    \"country_code\": 6.1
}"

const url = new URL(
    "https://api.getdentalray.com/api/user"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "username": "lysgoeulraesciarjymovmu",
    "email": "miguel47@example.com",
    "password": "R\/ub*E4l&Wa",
    "first_name": "veritatis",
    "last_name": "eos",
    "role": "quia",
    "activate": false,
    "phone_number": 3293.6102143,
    "country_code": 6.1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'username' => 'lysgoeulraesciarjymovmu',
            'email' => 'miguel47@example.com',
            'password' => 'R/ub*E4l&Wa',
            'first_name' => 'veritatis',
            'last_name' => 'eos',
            'role' => 'quia',
            'activate' => false,
            'phone_number' => 3293.6102143,
            'country_code' => 6.1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user'
payload = {
    "username": "lysgoeulraesciarjymovmu",
    "email": "miguel47@example.com",
    "password": "R\/ub*E4l&Wa",
    "first_name": "veritatis",
    "last_name": "eos",
    "role": "quia",
    "activate": false,
    "phone_number": 3293.6102143,
    "country_code": 6.1
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/user

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

username string

Must be at least 2 characters. Must not be greater than 255 characters. Example: lysgoeulraesciarjymovmu

email string

Must be a valid email address. Example: miguel47@example.com

password string

Example: R/ub*E4l&Wa

first_name string

Example: veritatis

last_name string

Example: eos

role string optional

Example: quia

permissions object optional

activate boolean optional true false

Example: false

phone_number number optional

Example: 3293.6102143

country_code number optional

Example: 6.1

office object optional

PUT api/user/mfa

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/user/mfa" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"default_factor\": \"sms\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/mfa"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "default_factor": "sms"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/user/mfa',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'default_factor' => 'sms',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/mfa'
payload = {
    "default_factor": "sms"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Change Password

requires authentication

This endpoint lets users change their own passwords

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user/change" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password_current\": \"animi\",
    \"password\": \"9.mfrvw&{\",
    \"password_confirmation\": \"cknwahyldeh\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/change"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "password_current": "animi",
    "password": "9.mfrvw&{",
    "password_confirmation": "cknwahyldeh"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user/change',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password_current' => 'animi',
            'password' => '9.mfrvw&{',
            'password_confirmation' => 'cknwahyldeh',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/change'
payload = {
    "password_current": "animi",
    "password": "9.mfrvw&{",
    "password_confirmation": "cknwahyldeh"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/user/change

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

password_current string

Example: animi

password string optional

This field is required when password_confirmation is present. The value and password_confirmation must match. Must be at least 6 characters. Must not be greater than 15 characters. Example: 9.mfrvw&{

password_confirmation string

Must be at least 6 characters. Must not be greater than 15 characters. Example: cknwahyldeh

GET api/user/{user_id}/offices

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1/offices" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/offices"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1/offices',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/offices'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

POST api/user/{user_id}/offices

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user/1/offices" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/offices"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user/1/offices',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/offices'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Get a User

requires authentication

This endpoint lets you get a User.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/user/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the user. Example: 1

Update a User

requires authentication

This endpoint lets you update a User's data.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/user/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"username\": \"vkdtuylfs\",
    \"email\": \"francis51@example.org\",
    \"first_name\": \"ddlisshbwnlphjsntxowv\",
    \"last_name\": \"qqjfudqdzlrbmjrq\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "username": "vkdtuylfs",
    "email": "francis51@example.org",
    "first_name": "ddlisshbwnlphjsntxowv",
    "last_name": "qqjfudqdzlrbmjrq"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/user/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'username' => 'vkdtuylfs',
            'email' => 'francis51@example.org',
            'first_name' => 'ddlisshbwnlphjsntxowv',
            'last_name' => 'qqjfudqdzlrbmjrq',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1'
payload = {
    "username": "vkdtuylfs",
    "email": "francis51@example.org",
    "first_name": "ddlisshbwnlphjsntxowv",
    "last_name": "qqjfudqdzlrbmjrq"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/user/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the user. Example: 1

Body Parameters

username string

Must be at least 5 characters. Must not be greater than 255 characters. Example: vkdtuylfs

email string

Must be a valid email address. Must not be greater than 255 characters. Example: francis51@example.org

first_name string optional

Must be at least 2 characters. Must not be greater than 100 characters. Example: ddlisshbwnlphjsntxowv

last_name string optional

Must be at least 2 characters. Must not be greater than 100 characters. Example: qqjfudqdzlrbmjrq

phone_number string optional

role string optional

POST api/user/{user_id}/mfa

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user/1/mfa" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/mfa"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user/1/mfa',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/mfa'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

DELETE api/user/{user_id}/mfa

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/user/1/mfa" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/mfa"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/user/1/mfa',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/mfa'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

GET api/user/{user_id}/qr

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1/qr" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/qr"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1/qr',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/qr'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Destroy a User

requires authentication

This endpoint lets you update a User.

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/user/1" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/user/1',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/user/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the user. Example: 1

User Meta Management

APIs for User Meta Management

Get all User Meta Data

requires authentication

This endpoint lets you get all User Meta

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1/meta" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/meta"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1/meta',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/meta'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/user/{user_id}/meta

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Store User Meta

requires authentication

This endpoint lets you store User Meta

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user/1/meta" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": \"corporis\",
    \"autoload\": false
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/meta"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": "corporis",
    "autoload": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user/1/meta',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 'corporis',
            'autoload' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/meta'
payload = {
    "user_id": "corporis",
    "autoload": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/user/{user_id}/meta

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Body Parameters

user_id string

Example: corporis

meta_value object optional

Must have at least 1 items. Must not have more than 10 items.

autoload boolean optional true false

Example: false

Show User Meta

requires authentication

This endpoint will return a single User Meta

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1/meta/nulla" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/meta/nulla"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1/meta/nulla',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/meta/nulla'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/user/{user_id}/meta/{key}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

key string

Example: nulla

Update User Meta

requires authentication

This endpoint will update a single User Meta

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/user/1/meta/earum" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"autoload\": false
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/meta/earum"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "autoload": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/user/1/meta/earum',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'autoload' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/meta/earum'
payload = {
    "autoload": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/user/{user_id}/meta/{key}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

key string

Example: earum

Body Parameters

meta_value object optional

Must have at least 1 items. Must not have more than 10 items.

autoload boolean optional true false

Example: false

Destroy User Meta

requires authentication

This endpoint will destroy a single User Meta

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/user/1/meta/ipsum" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/meta/ipsum"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/user/1/meta/ipsum',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/meta/ipsum'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/user/{user_id}/meta/{key}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

key string

Example: ipsum

User Permission Management

APIs for managing a User's Permissions

Get User Permission

requires authentication

This endpoint lets you get a User's Permissions

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1/permission" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/permission"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1/permission',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/permission'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/user/{user_id}/permission

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Update User Permission

requires authentication

This endpoint lets you update a Permission from a User

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/user/1/permission" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/permission"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/user/1/permission',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/permission'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

PUT api/user/{user_id}/permission

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Store User Permission

requires authentication

This endpoint lets you add a Permission to a User

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user/1/permission" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/permission"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user/1/permission',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/permission'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

POST api/user/{user_id}/permission

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Destroy User Permission

requires authentication

This endpoint lets you delete a Permission from a User

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/user/1/permission" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/permission"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/user/1/permission',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/permission'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/user/{user_id}/permission

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

User Role Management

APIs for managing a User's Role

Get User Roles

requires authentication

This endpoint lets you get a User's Roles

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/user/1/role" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/role"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/user/1/role',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/role'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/user/{user_id}/role

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Add Role to User

requires authentication

This endpoint lets you add a Role to a User.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/user/1/role" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"slug\": \"gdyuptatkqjjeymmaa\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/role"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "slug": "gdyuptatkqjjeymmaa"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/user/1/role',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'slug' => 'gdyuptatkqjjeymmaa',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/role'
payload = {
    "slug": "gdyuptatkqjjeymmaa"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/user/{user_id}/role

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Body Parameters

slug string optional

Must be at least 2 characters. Must not be greater than 100 characters. Example: gdyuptatkqjjeymmaa

Update Role to User

requires authentication

The endpoint lets you update a Role to a User

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/user/1/role" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"slug\": \"kuzdmsilsitrlpwfn\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/role"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "slug": "kuzdmsilsitrlpwfn"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/user/1/role',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'slug' => 'kuzdmsilsitrlpwfn',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/role'
payload = {
    "slug": "kuzdmsilsitrlpwfn"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/user/{user_id}/role

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Body Parameters

slug string

Must be at least 2 characters. Must not be greater than 20 characters. Example: kuzdmsilsitrlpwfn

Delete a User's Role

requires authentication

This endpoint lets you delete a User's Role

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/user/1/role" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"slug\": \"bbb\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/user/1/role"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "slug": "bbb"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/user/1/role',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'slug' => 'bbb',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/user/1/role'
payload = {
    "slug": "bbb"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

DELETE api/user/{user_id}/role

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

user_id integer

The ID of the user. Example: 1

Body Parameters

slug string optional

Must be at least 2 characters. Must not be greater than 100 characters. Example: bbb

Worklist Controller

APIs for managing Worklists

Get all Worklists

requires authentication

Display a listing of the resource.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/worklist" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/worklist"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/worklist',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/worklist'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

GET api/worklist/search-suggestions

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/worklist/search-suggestions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/worklist/search-suggestions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/worklist/search-suggestions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/worklist/search-suggestions'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store Worklist

requires authentication

Store a newly created resource in storage.

Example request:

curl --request POST \
    "https://api.getdentalray.com/api/worklist" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"office_id\": 5255.7,
    \"dentist_id\": 160,
    \"radiologist_id\": 1,
    \"media_id\": 27578.2664,
    \"patient_id\": 605181848,
    \"study_type\": \"comprehensive_read\",
    \"study_instance_uid\": \"perferendis\",
    \"link\": \"dignissimos\",
    \"status\": \"sapiente\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/worklist"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "office_id": 5255.7,
    "dentist_id": 160,
    "radiologist_id": 1,
    "media_id": 27578.2664,
    "patient_id": 605181848,
    "study_type": "comprehensive_read",
    "study_instance_uid": "perferendis",
    "link": "dignissimos",
    "status": "sapiente"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api.getdentalray.com/api/worklist',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'office_id' => 5255.7,
            'dentist_id' => 160.0,
            'radiologist_id' => 1.0,
            'media_id' => 27578.2664,
            'patient_id' => 605181848.0,
            'study_type' => 'comprehensive_read',
            'study_instance_uid' => 'perferendis',
            'link' => 'dignissimos',
            'status' => 'sapiente',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/worklist'
payload = {
    "office_id": 5255.7,
    "dentist_id": 160,
    "radiologist_id": 1,
    "media_id": 27578.2664,
    "patient_id": 605181848,
    "study_type": "comprehensive_read",
    "study_instance_uid": "perferendis",
    "link": "dignissimos",
    "status": "sapiente"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/worklist

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

Body Parameters

office_id number

Example: 5255.7

dentist_id number optional

Example: 160

radiologist_id number optional

Example: 1

media_id number optional

Example: 27578.2664

patient_id number

Example: 605181848

study_type string

Must be one of safety_overread or comprehensive_read. Example: comprehensive_read

study_instance_uid string optional

Example: perferendis

link string optional

Example: dignissimos

status string

Example: sapiente

Show Worklist

requires authentication

Display the specified resource.

Example request:

curl --request GET \
    --get "https://api.getdentalray.com/api/worklist/74" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/worklist/74"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api.getdentalray.com/api/worklist/74',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/worklist/74'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Request

GET api/worklist/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the worklist. Example: 74

Update Worklist

requires authentication

Update the specified resource in storage.

Example request:

curl --request PUT \
    "https://api.getdentalray.com/api/worklist/74" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"office_id\": 3,
    \"radiologist_id\": 457.7707,
    \"dentist_id\": 3803208.028,
    \"patient_id\": 45444060.1,
    \"study_type\": \"comprehensive_read\",
    \"link\": \"commodi\",
    \"status\": \"pending\"
}"

const url = new URL(
    "https://api.getdentalray.com/api/worklist/74"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "office_id": 3,
    "radiologist_id": 457.7707,
    "dentist_id": 3803208.028,
    "patient_id": 45444060.1,
    "study_type": "comprehensive_read",
    "link": "commodi",
    "status": "pending"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api.getdentalray.com/api/worklist/74',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'office_id' => 3.0,
            'radiologist_id' => 457.7707,
            'dentist_id' => 3803208.028,
            'patient_id' => 45444060.1,
            'study_type' => 'comprehensive_read',
            'link' => 'commodi',
            'status' => 'pending',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/worklist/74'
payload = {
    "office_id": 3,
    "radiologist_id": 457.7707,
    "dentist_id": 3803208.028,
    "patient_id": 45444060.1,
    "study_type": "comprehensive_read",
    "link": "commodi",
    "status": "pending"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/worklist/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the worklist. Example: 74

Body Parameters

office_id number

Example: 3

radiologist_id number optional

Example: 457.7707

dentist_id number optional

Example: 3803208.028

patient_id number

Example: 45444060.1

study_type string

Must be one of safety_overread or comprehensive_read. Example: comprehensive_read

link string optional

Example: commodi

status string optional

Must be one of pending or complete. Example: pending

Destroy Worklist

requires authentication

Remove the specified resource from storage.

Example request:

curl --request DELETE \
    "https://api.getdentalray.com/api/worklist/74" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://api.getdentalray.com/api/worklist/74"
);

const headers = {
    "Authorization": "Bearer {YOUR_AUTH_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api.getdentalray.com/api/worklist/74',
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://api.getdentalray.com/api/worklist/74'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Request

DELETE api/worklist/{id}

Headers

Authorization

Example: Bearer {YOUR_AUTH_KEY}

Content-Type

Example: application/json

Accept

Example: application/json

URL Parameters

id integer

The ID of the worklist. Example: 74

Introduction

Authenticating requests

Auth Multi-Factor Management

Get MFA Settings

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Send OTP

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Verify OTP

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Body Parameters

Category Management

Get all Categories

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Store a Category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Show a Category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Update a Category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Delete a Category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Dicom Management

Store Dicom

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Body Parameters

Update Dicom

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Body Parameters

Endpoints

Authenticate the request for channel access.

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Store User Heartbeat

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Body Parameters

Form Management

All Forms

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Store Form

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Show Form

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Media Management

Get all Media

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Store a Media

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Body Parameters

Show a Media

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Update a Media

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

URL Parameters

Delete a Media

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Headers

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request