NAV
cURL Node.JS Python Java Go

LifeOmic Core API v1.0.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

With the LifeOmic API, one can control all aspects of the enterprise Precision Health Platform programmatically. The client applications (Web Clients, Mobile Clients) offered by LifeOmic are powered by this public API. One may build their own third-party applications to tailor the platform to a set of needs and requirements.

The API is organized around REST.

JSON content-type is returned by API responses. Please include the header Content-Type=application/json for all requests.

The API uses conventional HTTP response codes to indicate the success or failure.

The Authorization API focuses on OAuth and API key support.

Base URLs:

Terms of service Web: API Support License: MIT

Authentication

Scope Scope Description

Cohorts

get-cohorts

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/cohorts?projectId=string \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/cohorts?projectId=string',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/cohorts', params={
  'projectId': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/cohorts?projectId=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/cohorts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /cohorts

Get cohorts.

Returns a list of cohorts that the user has access to.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
projectId query string true The ID of the project to search within for cohorts.
name query string false Only return cohorts that have a name that starts with the given value.
pageSize query number false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Example responses

200 Response

{
  "items": [
    {
      "name": "string",
      "description": "string",
      "ownerProject": "string",
      "resultCount": 0,
      "creatorUser": "string",
      "creationTime": "string",
      "queries": [
        {
          "project": "string",
          "queryType": "string",
          "query": {}
        }
      ]
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Cohorts

create-cohort

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/cohorts \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/cohorts',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/cohorts', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/cohorts");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/cohorts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /cohorts

Create a cohort

Create a cohort, representing a subset of a project based on one or more queries

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.

Example responses

200 Response

{
  "name": "string",
  "description": "string",
  "ownerProject": "string",
  "resultCount": 0,
  "creatorUser": "string",
  "creationTime": "string",
  "queries": [
    {
      "project": "string",
      "queryType": "string",
      "query": {}
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK none ResponseCohort

get-cohort

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/cohorts/{cohortId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/cohorts/{cohortId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/cohorts/{cohortId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/cohorts/{cohortId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/cohorts/{cohortId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /cohorts/{cohortId}

Get a cohort.

Returns a cohort.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
cohortId path string true The cohort id.

Example responses

200 Response

{
  "name": "string",
  "description": "string",
  "ownerProject": "string",
  "resultCount": 0,
  "creatorUser": "string",
  "creationTime": "string",
  "queries": [
    {
      "project": "string",
      "queryType": "string",
      "query": {}
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK none ResponseCohort

update-cohort

Code samples

# You can also use wget
curl -X PATCH https://api.us.lifeomic.com/v1/cohorts/{cohortId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/cohorts/{cohortId}',
{
  method: 'PATCH',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.patch('https://api.us.lifeomic.com/v1/cohorts/{cohortId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/cohorts/{cohortId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.us.lifeomic.com/v1/cohorts/{cohortId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /cohorts/{cohortId}

Update a cohort.

Returns the updated cohort.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
cohortId path string true The cohort id.

Example responses

200 Response

{
  "name": "string",
  "description": "string",
  "ownerProject": "string",
  "resultCount": 0,
  "creatorUser": "string",
  "creationTime": "string",
  "queries": [
    {
      "project": "string",
      "queryType": "string",
      "query": {}
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK none ResponseCohort

Accounts

List all accounts

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/accounts \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/accounts',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/accounts', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/accounts");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/accounts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /accounts

Retrieves a list of user accounts.

Returns a list of accounts that the user has access to.

Example responses

200 Response

{
  "accounts": [
    {
      "id": "string",
      "name": "string",
      "owner": "user@example.com",
      "type": "FREE"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK none Accounts

Create an account

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/accounts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "name": "string",
  "owner": "user@example.com",
  "type": "FREE"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/accounts',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/accounts', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/accounts");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/accounts", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /accounts

Creates an account.

Creates an account, returning the account object.

Body parameter

{
  "id": "string",
  "name": "string",
  "owner": "user@example.com",
  "type": "FREE"
}

Parameters

Name In Type Required Description
body body Account true none

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "owner": "user@example.com",
  "type": "FREE"
}

Responses

Status Meaning Description Schema
200 OK none Account

Retrieve an account

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/accounts/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/accounts/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/accounts/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/accounts/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/accounts/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /accounts/{id}

Retrieves an account.

Retrieves details about an account. Returns the account object.

Parameters

Name In Type Required Description
id path string true The account id.
include query string false Include additional information like the user's groups.

Enumerated Values

Parameter Value
include groups

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "owner": "user@example.com",
  "type": "FREE"
}

Responses

Status Meaning Description Schema
200 OK none Account

Update an account

Code samples

# You can also use wget
curl -X PATCH https://api.us.lifeomic.com/v1/accounts/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "deletionDate": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/accounts/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.patch('https://api.us.lifeomic.com/v1/accounts/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/accounts/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.us.lifeomic.com/v1/accounts/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /accounts/{id}

Updates an account.

Update an account by changing the name or clearing out a pending deletion date. Returns the account object.

Body parameter

{
  "name": "string",
  "deletionDate": "string"
}

Parameters

Name In Type Required Description
id path string true The account id.
body body UpdateAccount true none

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "owner": "user@example.com",
  "type": "FREE"
}

Responses

Status Meaning Description Schema
200 OK none Account

Delete an account

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/accounts/{id} \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/accounts/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/accounts/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/accounts/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/accounts/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /accounts/{id}

Deletes an account.

Deletes an account. By default, the account will not be deleted for 14 days. During this time, the pending deletion can be cancelled by using the PATCH method. After the 14 day grace period, the account and all of it's data will be removed.

Parameters

Name In Type Required Description
id path string true The account id.
force query boolean false If true, the 14 day grace period will be ignored and all of the account data will be removed immediately.

Responses

Status Meaning Description Schema
204 No Content Gone None

Account Clients

List clients

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/clients \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/clients',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /clients

Retrieves a list of accounts.

Returns a list of clients belonging to an account.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The account id.

Example responses

200 Response

{
  "clients": [
    {
      "id": "string",
      "name": "string",
      "generateSecret": true,
      "callbackUrls": [
        "string"
      ],
      "logoutUrls": [
        "string"
      ],
      "identityProviders": [
        "GOOGLE"
      ],
      "allowedOAuthFlows": [
        "code"
      ],
      "customIdentityProvider": {
        "attributeMapping": [
          "string"
        ],
        "metadataUrl": "string"
      }
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK none Clients

Create client

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/clients \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/clients',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/clients', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/clients", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /clients

Creates a client.

Create a new client for an account. Returns the client object.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The account id.

Example responses

201 Response

{
  "id": "string",
  "name": "string",
  "generateSecret": true,
  "callbackUrls": [
    "string"
  ],
  "logoutUrls": [
    "string"
  ],
  "identityProviders": [
    "GOOGLE"
  ],
  "allowedOAuthFlows": [
    "code"
  ],
  "customIdentityProvider": {
    "attributeMapping": [
      "string"
    ],
    "metadataUrl": "string"
  }
}

Responses

Status Meaning Description Schema
201 Created none Client

Retrieve a client

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/clients/{clientId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/clients/{clientId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/clients/{clientId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/clients/{clientId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/clients/{clientId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /clients/{clientId}

Retrieves a client.

Retrieves an account by clientId.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The account id.
clientId path string true The client id.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "generateSecret": true,
  "callbackUrls": [
    "string"
  ],
  "logoutUrls": [
    "string"
  ],
  "identityProviders": [
    "GOOGLE"
  ],
  "allowedOAuthFlows": [
    "code"
  ],
  "customIdentityProvider": {
    "attributeMapping": [
      "string"
    ],
    "metadataUrl": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Client

Update a client

Code samples

# You can also use wget
curl -X PUT https://api.us.lifeomic.com/v1/clients/{clientId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/clients/{clientId}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.put('https://api.us.lifeomic.com/v1/clients/{clientId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/clients/{clientId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.us.lifeomic.com/v1/clients/{clientId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /clients/{clientId}

Updates a client.

Updates a client for an account.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The account id.
clientId path string true The client id.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "generateSecret": true,
  "callbackUrls": [
    "string"
  ],
  "logoutUrls": [
    "string"
  ],
  "identityProviders": [
    "GOOGLE"
  ],
  "allowedOAuthFlows": [
    "code"
  ],
  "customIdentityProvider": {
    "attributeMapping": [
      "string"
    ],
    "metadataUrl": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Client

Delete a client

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/clients/{clientId} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/clients/{clientId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/clients/{clientId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/clients/{clientId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/clients/{clientId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /clients/{clientId}

Delete an account client.

Deletes an account client.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The account id.
clientId path string true The client id.

Responses

Status Meaning Description Schema
204 No Content Gone None

Projects

List projects

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/projects \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/projects',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/projects', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/projects");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/projects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /projects

Retrieves a list of projects.

Returns a list of all projects.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
name query string false Filters the result set by performing a case-insensitive begins with filter on the project name.
pageSize query number false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "name": "string",
      "deletionDate": "string"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Projects

Create a project

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/projects \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/projects',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/projects', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/projects");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/projects", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /projects

Creates a project

Creates a project. Some resources refer to projects as datasets. The id of a project should be used whenever a datasetId is needed.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "deletionDate": "string"
}

Responses

Status Meaning Description Schema
200 OK none Project

Retrieve a project

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/projects/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/projects/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/projects/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/projects/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/projects/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /projects/{id}

Retrieves a project.

Retrieves the details of a project. Returns an project object.

Parameters

Name In Type Required Description
id path string true The project id.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "deletionDate": "string"
}

Responses

Status Meaning Description Schema
200 OK none Project

Update a project

Code samples

# You can also use wget
curl -X PATCH https://api.us.lifeomic.com/v1/projects/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/projects/{id}',
{
  method: 'PATCH',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.patch('https://api.us.lifeomic.com/v1/projects/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/projects/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.us.lifeomic.com/v1/projects/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /projects/{id}

Updates a project.

Updates a project by changing the name or clearing out a pending deletion date.

Parameters

Name In Type Required Description
id path string true The project id.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "deletionDate": "string"
}

Responses

Status Meaning Description Schema
200 OK none Project

Delete a project

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/projects/{id} \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/projects/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/projects/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/projects/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/projects/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /projects/{id}

Deletes a project.

Deletes a project. By default, the project will not be deleted for 14 days. During this time, the pending deletion can be cancelled by using the PATCH method. After the 14 day grace period, the project and all of it's data will be removed.

Parameters

Name In Type Required Description
id path string true The project id.
force query boolean false If true, the 14 day grace period will be ignored and all of the project data will be removed immediately.

Responses

Status Meaning Description Schema
204 No Content Gone None

Files

List files

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/files \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/files',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/files', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/files");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/files", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /files

Retrieves a list of files.

Returns a list of files that the user has access to.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
name query string false Filters the result set by performing a case-insensitive begins with filter on the file name.
orderBy query string false Allows one to order the results by file name or by size. Default is to sort by name in ascending order. To sort in descending order, add desc to the end of the value.
pageSize query number false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.
projectId query string false Only return files in the specified project.

Enumerated Values

Parameter Value
orderBy name
orderBy size

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "name": "string",
      "datasetId": "string",
      "contentType": "string"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Files

Create a file

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/files \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "name": "string",
  "datasetId": "string",
  "contentType": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/files',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/files', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/files");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/files", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /files

Creates a file

Creates a file. The bytes must be uploaded using a PUT request to the uploadUrl returned in the response. If an id is specified in the request body, then any existing file at that id will be overwritten.

Body parameter

{
  "id": "string",
  "name": "string",
  "datasetId": "string",
  "contentType": "string"
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
body body File true none

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "uploadUrl": "string",
  "datasetId": "string",
  "contentType": "string"
}

Responses

Status Meaning Description Schema
200 OK none FileUploadResponse

Retrieve a file

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/files/{id} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/files/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/files/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/files/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/files/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /files/{id}

Download a file.

Download a file.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The file id.
include query string false Specifying a value of downloadUrl will return the download URL for the file.

Enumerated Values

Parameter Value
include downloadUrl

Responses

Status Meaning Description Schema
200 OK The file content None

Delete a file

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/files/{id} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/files/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/files/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/files/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/files/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /files/{id}

Deletes a file.

Deletes a file.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The file id.

Responses

Status Meaning Description Schema
204 No Content Gone None

Groups

List groups

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/account/groups \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/account/groups',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/account/groups', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/account/groups");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/account/groups", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /account/groups

Retrieve a list of groups.

Returns the list of groups for an account.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
name query string false Search for groups whose name starts with the given string.

Example responses

200 Response

{
  "items": [
    {
      "account": "string",
      "description": "string",
      "id": "string",
      "type": "closed"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A list of groups Groups

Retrieve a group

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/account/groups/{id} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/account/groups/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/account/groups/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/account/groups/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/account/groups/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /account/groups/{id}

Retrieve a group by ID.

Returns the group with the given ID.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The group ID to lookup.

Example responses

200 Response

{
  "account": "string",
  "description": "string",
  "id": "string",
  "type": "closed"
}

Responses

Status Meaning Description Schema
200 OK none Group

Update a group

Code samples

# You can also use wget
curl -X PUT https://api.us.lifeomic.com/v1/account/groups/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "account": "string",
  "description": "string",
  "id": "string",
  "type": "closed"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/account/groups/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.put('https://api.us.lifeomic.com/v1/account/groups/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/account/groups/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.us.lifeomic.com/v1/account/groups/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /account/groups/{id}

Updates a group.

Updates the group identified by the given ID.

Body parameter

{
  "account": "string",
  "description": "string",
  "id": "string",
  "type": "closed"
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The group ID to modify.
body body Group true The new information for the group.

Example responses

200 Response

{
  "account": "string",
  "description": "string",
  "id": "string",
  "type": "closed"
}

Responses

Status Meaning Description Schema
200 OK none Group

List group members

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/account/groups/{id}/members \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/account/groups/{id}/members',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/account/groups/{id}/members', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/account/groups/{id}/members");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/account/groups/{id}/members", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /account/groups/{id}/members

Retrieve a list of group members

Returns the list of users belonging to the group.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The ID of the group

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "type": "string",
      "profile": {
        "email": "string",
        "familyName": "string",
        "givenName": "string",
        "name": "string",
        "picture": "string",
        "preferredUsername": "string"
      }
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Users

Delete a group member

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/account/groups/{id}/members \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/account/groups/{id}/members',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/account/groups/{id}/members', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/account/groups/{id}/members");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/account/groups/{id}/members", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /account/groups/{id}/members

Removes a member from a group

Removes the user from a group.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
id path string true The ID of the group
username path string true The user to add to the group

Responses

Status Meaning Description Schema
204 No Content none None

Users

Retrieve current user

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/user \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/user',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/user', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/user");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/user", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /user

Retrieves the authenticated user

Returns the full profile for the currently authenticated user

Example responses

200 Response

{
  "id": "string",
  "type": "string",
  "profile": {
    "email": "string",
    "familyName": "string",
    "givenName": "string",
    "name": "string",
    "picture": "string",
    "preferredUsername": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK The user's profile User

Update current user

Code samples

# You can also use wget
curl -X PATCH https://api.us.lifeomic.com/v1/user \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "profile": {
    "email": "string",
    "familyName": "string",
    "givenName": "string",
    "name": "string",
    "picture": "string",
    "preferredUsername": "string"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/user',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.patch('https://api.us.lifeomic.com/v1/user', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/user");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.us.lifeomic.com/v1/user", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /user

Updates the current user's profile

Updates the authenticated user's profile

Body parameter

{
  "profile": {
    "email": "string",
    "familyName": "string",
    "givenName": "string",
    "name": "string",
    "picture": "string",
    "preferredUsername": "string"
  }
}

Parameters

Name In Type Required Description
body body UpdateUser true none

Example responses

200 Response

{
  "id": "string",
  "type": "string",
  "profile": {
    "email": "string",
    "familyName": "string",
    "givenName": "string",
    "name": "string",
    "picture": "string",
    "preferredUsername": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK The updated profile User

Retrieve a user

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/users/{username} \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/users/{username}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/users/{username}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/users/{username}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/users/{username}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /users/{username}

Retrieves a user's profile

Returns a users profile. When requesting one's own profile the full profile is returned. Otherwise a limited profile is returned.

Parameters

Name In Type Required Description
username path string true The user to lookup

Example responses

200 Response

{
  "id": "string",
  "type": "string",
  "profile": {
    "email": "string",
    "familyName": "string",
    "givenName": "string",
    "name": "string",
    "picture": "string",
    "preferredUsername": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK The user profile User

List user groups

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/users/{username}/groups \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/users/{username}/groups',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/users/{username}/groups', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/users/{username}/groups");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/users/{username}/groups", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /users/{username}/groups

Retrieves a list of groups that the user is a member of

Returns a list of groups that the user is a member of. This currently only succeeds if a user is asking for their own groups.

Parameters

Name In Type Required Description
username path string true The user to list groups for

Example responses

200 Response

{
  "items": [
    {
      "account": "string",
      "description": "string",
      "id": "string",
      "type": "closed"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A list of groups Groups

Retrieve user picture

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/users/{username}/picture \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/users/{username}/picture',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/users/{username}/picture', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/users/{username}/picture");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/users/{username}/picture", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /users/{username}/picture

Retrieves metadata for the user's profile picture

Returns profile picture metadata.

Parameters

Name In Type Required Description
username path string true The user to retrieve profile picture information for

Example responses

200 Response

{
  "downloadUrl": "string"
}

Responses

Status Meaning Description Schema
200 OK Profile picture metadata ProfilePicture

Update user picture

Code samples

# You can also use wget
curl -X PUT https://api.us.lifeomic.com/v1/users/{username}/picture \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Content-Type: string' \
  -H 'Content-Length: 0' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = 'string';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Content-Type':'string',
  'Content-Length':'0',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/users/{username}/picture',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Content-Type': 'string',
  'Content-Length': '0',
  'Authorization': 'API_KEY'
}

r = requests.put('https://api.us.lifeomic.com/v1/users/{username}/picture', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/users/{username}/picture");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Content-Type": []string{"string"},
        "Content-Length": []string{"0"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.us.lifeomic.com/v1/users/{username}/picture", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /users/{username}/picture

Updates a user's profile picture

Update a user's profile picture. This only for the currently authorized user using a LifeOmic account.

Body parameter

"string"

Parameters

Name In Type Required Description
username path string true The user to update the profile picture for
Content-Type header string true The MIME type of the image being uploaded
Content-Length header number true The size of the image payload in bytes
body body string(binary) true The binary profile picture content

Example responses

200 Response

{
  "downloadUrl": "string"
}

Responses

Status Meaning Description Schema
200 OK Metadata about the new profile image ProfilePicture

Policy

Retrieve evaluated policy

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/evaluated-policy \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/evaluated-policy',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/evaluated-policy', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/evaluated-policy");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/evaluated-policy", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /evaluated-policy

Retrieve the current user's ABAC policies

See our open-sourced implementation of parsing ABAC policies at https://github.com/lifeomic/abac

Example responses

200 Response

{
  "rules": {
    "apiKeyUser": true,
    "createData": [
      {
        "resource.dataset": {
          "comparison": "equals",
          "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
        }
      }
    ],
    "readData": [
      {
        "resource.dataset": {
          "comparison": "equals",
          "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
        }
      }
    ],
    "readMaskedData": [
      {
        "resource.dataset": {
          "comparison": "equals",
          "value": "fc4c2a5e-6f24-4880-a5b7-c3ae51de1657"
        }
      }
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK An ABAC policy document Policy

List policies

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/policies \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/policies',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/policies', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/policies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/policies", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /policies

Retrieves a list of policies.

Retrieves a list of policies for an account.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.

Responses

Status Meaning Description Schema

Create policy

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/policies \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/policies',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/policies', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/policies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/policies", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /policies

Creates a policy.

Create a new policy for an account.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account.

Responses

Status Meaning Description Schema

Update a policy

Code samples

# You can also use wget
curl -X PUT https://api.us.lifeomic.com/v1/policies/{policyId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "name": "string",
  "policy": {
    "rules": {
      "apiKeyUser": true,
      "createData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
          }
        }
      ],
      "readData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
          }
        }
      ],
      "readMaskedData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "fc4c2a5e-6f24-4880-a5b7-c3ae51de1657"
          }
        }
      ]
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/policies/{policyId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.put('https://api.us.lifeomic.com/v1/policies/{policyId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/policies/{policyId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.us.lifeomic.com/v1/policies/{policyId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /policies/{policyId}

Updates a policy.

Updates a policy for an account.

Body parameter

{
  "name": "string",
  "policy": {
    "rules": {
      "apiKeyUser": true,
      "createData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
          }
        }
      ],
      "readData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
          }
        }
      ],
      "readMaskedData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "fc4c2a5e-6f24-4880-a5b7-c3ae51de1657"
          }
        }
      ]
    }
  }
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account.
policyId path string true The policy id.
body body object false none
» name body string false Policy name
» policy body Policy false An ABAC policy document.
»» rules body object true none
»»» propertyNames body OperationNames false The set of valid operation names
»»» additionalProperties body any false An ABAC rules list or true
»»»» anonymous body [Rule] false [An individual ABAC policy rule]
»»»»» patternProperties body Comparison false An individual ABAC attribute comparison
»»»»»» anonymous body object false none
»»»»»»» comparison body string true equals or includes comparison.
»»»»»»» value body string true ABAC rule.
»»»»»» anonymous body object false none
»»»»»»» comparison body string true superset comparison.
»»»»»»» value body [string] true List of ABAC rules.
»»»»»» anonymous body object false none
»»»»»»» comparison body string true equals, includes, or superset comparison.
»»»»»»» target body string true Target ABAC rule
»»»»»» anonymous body object false none
»»»»»»» comparison body string true exists comparison.
»»»»»» anonymous body boolean false none

Enumerated Values

Parameter Value
»»»»»»» comparison equals
»»»»»»» comparison includes
»»»»»»» comparison superset
»»»»»»» comparison exists

Example responses

200 Response

{
  "name": "string",
  "policy": {
    "rules": {
      "apiKeyUser": true,
      "createData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
          }
        }
      ],
      "readData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "eed10b7f-8b8d-4182-a10b-7bf541ed4e36"
          }
        }
      ],
      "readMaskedData": [
        {
          "resource.dataset": {
            "comparison": "equals",
            "value": "fc4c2a5e-6f24-4880-a5b7-c3ae51de1657"
          }
        }
      ]
    }
  }
}

Responses

Status Meaning Description Schema
200 OK none Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» name string false none Policy name
» policy Policy false none An ABAC policy document.
»» rules object true none none
»»» propertyNames OperationNames false none The set of valid operation names
»»» additionalProperties any false none An ABAC rules list or true

oneOf

Name Type Required Restrictions Description
»»»» anonymous [Rule] false none [An individual ABAC policy rule]
»»»»» patternProperties Comparison false none An individual ABAC attribute comparison

oneOf

Name Type Required Restrictions Description
»»»»»» anonymous object false none none
»»»»»»» comparison string true none equals or includes comparison.
»»»»»»» value string true none ABAC rule.

xor

Name Type Required Restrictions Description
»»»»»» anonymous object false none none
»»»»»»» comparison string true none superset comparison.
»»»»»»» value [string] true none List of ABAC rules.

xor

Name Type Required Restrictions Description
»»»»»» anonymous object false none none
»»»»»»» comparison string true none equals, includes, or superset comparison.
»»»»»»» target string true none Target ABAC rule

xor

Name Type Required Restrictions Description
»»»»»» anonymous object false none none
»»»»»»» comparison string true none exists comparison.

xor

Name Type Required Restrictions Description
»»»»»» anonymous boolean false none none

Enumerated Values

Property Value
comparison equals
comparison includes
comparison superset
comparison exists

Delete a policy

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/policies/{policyId} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/policies/{policyId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/policies/{policyId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/policies/{policyId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/policies/{policyId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /policies/{policyId}

Deletes a policy.

Deletes a policy for an account.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account.
policyId path string true The policy id.

Responses

Status Meaning Description Schema
204 No Content Gone None

Analytics

Query analytics

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/analytics/dsl \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/analytics/dsl',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/analytics/dsl', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/analytics/dsl");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/analytics/dsl", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /analytics/dsl

Query the analytics databases

Returns the results a query that may span patients, genetic variants, and gene expression data

Body parameter

{}

Parameters

Name In Type Required Description
body body AnalyticsDSL true none

Example responses

200 Response

{
  "data": {}
}

Responses

Status Meaning Description Schema
200 OK none Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
» data object true none none

Invitations

Retrieve invitations

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/invitations \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/invitations',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/invitations', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/invitations");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/invitations", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /invitations

Retrieves the invitations to or from the session user.

Returns a list of invitations received or sent by the user, depending on parameters.

Parameters

Name In Type Required Description
user query string false The session user, whose received invitations should be fetched.
account query string false The account in which group invitations sent by the session user should be fetched.

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "account": "string",
      "accountName": "string",
      "group": "string",
      "groupName": "string",
      "invitorUser": "string",
      "email": "string",
      "status": "AWAITING-USER-ACTION",
      "inviteTimestamp": "string",
      "expirationTimestamp": "string"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Invitations

Invite a user

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/invitations \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "group": "string",
  "email": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/invitations',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/invitations', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/invitations");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/invitations", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /invitations

Invites a user to join a group

Sends an email to a user, inviting them to join a group

Body parameter

{
  "group": "string",
  "email": "string"
}

Parameters

Name In Type Required Description
body body CreateInvitation true none

Example responses

200 Response

{
  "id": "string",
  "account": "string",
  "accountName": "string",
  "group": "string",
  "groupName": "string",
  "invitorUser": "string",
  "email": "string",
  "status": "AWAITING-USER-ACTION",
  "inviteTimestamp": "string",
  "expirationTimestamp": "string"
}

Responses

Status Meaning Description Schema
200 OK The created invitation Invitation

Update an invitation

Code samples

# You can also use wget
curl -X PATCH https://api.us.lifeomic.com/v1/invitations/{id} \
  -H 'Content-Type: application/json' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "status": "ACCEPTED"
}';
const headers = {
  'Content-Type':'application/json',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/invitations/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'API_KEY'
}

r = requests.patch('https://api.us.lifeomic.com/v1/invitations/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/invitations/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.us.lifeomic.com/v1/invitations/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /invitations/{id}

Join, reject, or revoke an invitation.

Performs an action on the invitation. If revoking an invitation, the accessAdmin Access Policy Privilege is required

Body parameter

{
  "status": "ACCEPTED"
}

Parameters

Name In Type Required Description
id path string true The invitation ID to modify.
body body UpdateInvitation true none

Responses

Status Meaning Description Schema
200 OK Modified invitation None

EHRs

get-ehrs

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs

Get ehrs.

Returns a list of EHRs that the user has access to.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "name": "string",
      "ehrType": "string",
      "creator": "string",
      "apiBaseUrl": "string",
      "apiAuthType": "string",
      "ingestionModel": "string",
      "delayBetweenRecords": 0
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none EHRs

create-ehr

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/ehrs \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "name": "string",
  "ehrType": "cerbo",
  "apiBaseUrl": "http://example.com",
  "apiKey": "string",
  "apiSecret": "string",
  "apiAuthType": "header",
  "ingestionModel": "ASYNCHRONOUS",
  "delayBetweenRecords": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/ehrs', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/ehrs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /ehrs

Create an EHR configuration

Create an EHR configuration, which can then be connected to projects and used to sync data from your EHR to the PHC.

Body parameter

{
  "id": "string",
  "name": "string",
  "ehrType": "cerbo",
  "apiBaseUrl": "http://example.com",
  "apiKey": "string",
  "apiSecret": "string",
  "apiAuthType": "header",
  "ingestionModel": "ASYNCHRONOUS",
  "delayBetweenRecords": 0
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
body body EHR true none

Example responses

201 Response

{
  "id": "string",
  "name": "string",
  "ehrType": "cerbo",
  "apiBaseUrl": "http://example.com",
  "apiKey": "string",
  "apiSecret": "string",
  "apiAuthType": "header",
  "ingestionModel": "ASYNCHRONOUS",
  "delayBetweenRecords": 0
}

Responses

Status Meaning Description Schema
201 Created none EHR

get-ehr

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}

Get an EHR.

Returns an EHR.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "ehrType": "cerbo",
  "apiBaseUrl": "http://example.com",
  "apiKey": "string",
  "apiSecret": "string",
  "apiAuthType": "header",
  "ingestionModel": "ASYNCHRONOUS",
  "delayBetweenRecords": 0
}

Responses

Status Meaning Description Schema
200 OK none EHR

update-ehr

Code samples

# You can also use wget
curl -X UPDATE https://api.us.lifeomic.com/v1/ehrs/{ehrId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}',
{
  method: 'UPDATE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.update('https://api.us.lifeomic.com/v1/ehrs/{ehrId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("UPDATE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("UPDATE", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

UPDATE /ehrs/{ehrId}

Update an EHR.

Updates an EHR.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "ehrType": "cerbo",
  "apiBaseUrl": "http://example.com",
  "apiKey": "string",
  "apiSecret": "string",
  "apiAuthType": "header",
  "ingestionModel": "ASYNCHRONOUS",
  "delayBetweenRecords": 0
}

Responses

Status Meaning Description Schema
200 OK none EHR

delete-ehr

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/ehrs/{ehrId} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/ehrs/{ehrId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /ehrs/{ehrId}

Delete an EHR.

Deletes an EHR.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.

Responses

Status Meaning Description Schema
204 No Content none None

get-connectors

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}/connectors

Get EHR connectors.

Returns a list of project connectors configured for this EHR.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "ehrId": "string",
      "project": "string"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none EHRConnectors

create-connector

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "id": "string",
  "ehrId": "string",
  "project": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /ehrs/{ehrId}/connectors

Create an EHR project connector

Creates an EHR project connector, which represents the ability for this EHR to tie ingested records to the connected project.

Body parameter

{
  "id": "string",
  "ehrId": "string",
  "project": "string"
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
body body EHRConnector true none

Example responses

201 Response

{
  "id": "string",
  "ehrId": "string",
  "project": "string"
}

Responses

Status Meaning Description Schema
201 Created none EHRConnector

get-connector

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}/connectors/{connectorId}

Get EHR connector.

Returns an EHR project connector.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
connectorId path string true The EHR connector id.

Example responses

200 Response

{
  "id": "string",
  "ehrId": "string",
  "project": "string"
}

Responses

Status Meaning Description Schema
200 OK none EHRConnector

delete-connector

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/connectors/{connectorId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /ehrs/{ehrId}/connectors/{connectorId}

Delete the EHR connector.

Deletes the EHR project connector.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
connectorId path string true The EHR connector id.

Responses

Status Meaning Description Schema
204 No Content none None

get-ingestions

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}/ingestions

Get EHR ingestions.

Returns a list of EHR ingestions.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.

Example responses

200 Response

{
  "items": [
    {
      "connectors": [
        {
          "id": "string",
          "ehrId": "string",
          "project": "string"
        }
      ],
      "records": [
        {
          "type": "string",
          "id": "string"
        }
      ],
      "consumePendingUpdates": true
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none EHRIngestions

create-ingestion

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "connectors": [
    {
      "id": "string",
      "ehrId": "string",
      "project": "string"
    }
  ],
  "records": [
    {
      "type": "string",
      "id": "string"
    }
  ],
  "consumePendingUpdates": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /ehrs/{ehrId}/ingestions

Create an EHR ingestion

Creates an EHR ingestion, which represents a synchronization of EHR data to the PHC.

Body parameter

{
  "connectors": [
    {
      "id": "string",
      "ehrId": "string",
      "project": "string"
    }
  ],
  "records": [
    {
      "type": "string",
      "id": "string"
    }
  ],
  "consumePendingUpdates": true
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
body body EHRIngestion true none

Example responses

201 Response

{
  "connectors": [
    {
      "id": "string",
      "ehrId": "string",
      "project": "string"
    }
  ],
  "records": [
    {
      "type": "string",
      "id": "string"
    }
  ],
  "consumePendingUpdates": true
}

Responses

Status Meaning Description Schema
201 Created none EHRIngestion

get-ingestion

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions/{ingestionId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions/{ingestionId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions/{ingestionId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions/{ingestionId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/ingestions/{ingestionId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}/ingestions/{ingestionId}

Get EHR ingestion.

Returns a an EHR ingestions.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
ingestionId path string true The EHR ingestion id.

Example responses

200 Response

{
  "items": [
    {
      "connectors": [
        {
          "id": "string",
          "ehrId": "string",
          "project": "string"
        }
      ],
      "records": [
        {
          "type": "string",
          "id": "string"
        }
      ],
      "consumePendingUpdates": true
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none EHRIngestions

get-scheduled-ingestions

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}/scheduled-ingestions

Get scheduled EHR ingestions.

Returns a list of scheduled EHR ingestions.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.

Example responses

200 Response

{
  "items": [
    {
      "ingestion": {
        "connectors": [
          {
            "id": "string",
            "ehrId": "string",
            "project": "string"
          }
        ],
        "records": [
          {
            "type": "string",
            "id": "string"
          }
        ],
        "consumePendingUpdates": true
      },
      "cronExpression": "string"
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none EHRScheduledIngestions

create-scheduled-ingestion

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "ingestion": {
    "connectors": [
      {
        "id": "string",
        "ehrId": "string",
        "project": "string"
      }
    ],
    "records": [
      {
        "type": "string",
        "id": "string"
      }
    ],
    "consumePendingUpdates": true
  },
  "cronExpression": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /ehrs/{ehrId}/scheduled-ingestions

Schedule an EHR ingestion

Creates a recurring schedule on which an EHR ingestion should run.

Body parameter

{
  "ingestion": {
    "connectors": [
      {
        "id": "string",
        "ehrId": "string",
        "project": "string"
      }
    ],
    "records": [
      {
        "type": "string",
        "id": "string"
      }
    ],
    "consumePendingUpdates": true
  },
  "cronExpression": "string"
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
body body EHRScheduledIngestion true none

Example responses

201 Response

{
  "ingestion": {
    "connectors": [
      {
        "id": "string",
        "ehrId": "string",
        "project": "string"
      }
    ],
    "records": [
      {
        "type": "string",
        "id": "string"
      }
    ],
    "consumePendingUpdates": true
  },
  "cronExpression": "string"
}

Responses

Status Meaning Description Schema
201 Created none EHRScheduledIngestion

get-scheduled-ingestion

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}

Get scheduled EHR ingestion.

Returns a scheduled EHR ingestion.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
scheduledIngestionId path string true The scheduled EHR ingestion id.

Example responses

200 Response

{
  "ingestion": {
    "connectors": [
      {
        "id": "string",
        "ehrId": "string",
        "project": "string"
      }
    ],
    "records": [
      {
        "type": "string",
        "id": "string"
      }
    ],
    "consumePendingUpdates": true
  },
  "cronExpression": "string"
}

Responses

Status Meaning Description Schema
200 OK none EHRScheduledIngestion

delete-scheduled-ingestion

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /ehrs/{ehrId}/scheduled-ingestions/{scheduledIngestionId}

Delete the scheduled EHR ingestion.

Deletes the scheduled EHR ingestion.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
ehrId path string true The EHR id.
scheduledIngestionId path string true The scheduled EHR ingestion id.

Responses

Status Meaning Description Schema
204 No Content none None

FHIR

search-project

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/fhir-search/projects/{project} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "type": "select",
  "columns": "*",
  "from": [
    {
      "table": "string"
    }
  ],
  "where": {
    "type": "elasticsearch",
    "query": {},
    "highlight": {}
  },
  "limit": [
    {
      "type": "number",
      "value": 0
    },
    {
      "type": "number",
      "value": 0
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/fhir-search/projects/{project}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/fhir-search/projects/{project}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/fhir-search/projects/{project}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/fhir-search/projects/{project}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /fhir-search/projects/{project}

Search a project's FHIR resources using an expressive DSL

For additional information and examples see the user guide

Body parameter

{
  "type": "select",
  "columns": "*",
  "from": [
    {
      "table": "string"
    }
  ],
  "where": {
    "type": "elasticsearch",
    "query": {},
    "highlight": {}
  },
  "limit": [
    {
      "type": "number",
      "value": 0
    },
    {
      "type": "number",
      "value": 0
    }
  ]
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true The target project identifier
scroll query string false The _scroll_id from the previous request, which should be used to retrieve the next batch of results.
body body FHIR true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK The request was successful Inline

Response Schema

search-patient

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/fhir-search/projects/{project}/patients/{patient} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "type": "select",
  "columns": "*",
  "from": [
    {
      "table": "string"
    }
  ],
  "where": {
    "type": "elasticsearch",
    "query": {},
    "highlight": {}
  },
  "limit": [
    {
      "type": "number",
      "value": 0
    },
    {
      "type": "number",
      "value": 0
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/fhir-search/projects/{project}/patients/{patient}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/fhir-search/projects/{project}/patients/{patient}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/fhir-search/projects/{project}/patients/{patient}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/fhir-search/projects/{project}/patients/{patient}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /fhir-search/projects/{project}/patients/{patient}

Search a patient's FHIR resources using an expressive DSL

For additional information and examples see the user guide

Body parameter

{
  "type": "select",
  "columns": "*",
  "from": [
    {
      "table": "string"
    }
  ],
  "where": {
    "type": "elasticsearch",
    "query": {},
    "highlight": {}
  },
  "limit": [
    {
      "type": "number",
      "value": 0
    },
    {
      "type": "number",
      "value": 0
    }
  ]
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true The target project identifier
patient path string true The target patient identifier
body body FHIR true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK The request was successful Inline

Response Schema

Genomics

Get tests

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /genomics/projects/{projectId}/tests

Get genomic tests for a project.

A genomic test represents a single sequencing event that has been added to the PHC. The resource contains metadata about the event like tissue body site information and dates when the test was collected. It contains the list of genomic sets that make up the test under the sets property.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
projectId path string true The project id.
patientId query string false Only return tests for a specific patient Id.
status query string false Only return tests that are in a given status
type query string false Only return tests that are in a given type
pageSize query string false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Enumerated Values

Parameter Value
status ACTIVE
status INDEXING
status FAILED
type shortVariant
type expression
type structuralVariant
type copyNumberVariant
type read

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "datasetId": "string",
      "name": "string",
      "reportFileId": "string",
      "indexedDate": "2019-08-24T14:15:22Z",
      "createdDate": "2019-08-24T14:15:22Z",
      "testType": "string",
      "referenceSetId": "GRCh37",
      "msi": "string",
      "tmb": {
        "status": "string",
        "score": 0
      },
      "sourceFileId": "string",
      "patientId": "string",
      "status": "ACTIVE",
      "tasks": [
        "string"
      ],
      "sets": [
        {
          "id": "string",
          "name": "string",
          "setType": "shortVariant",
          "sequenceId": "string",
          "fileId": "string",
          "sequenceType": "somatic",
          "status": "ACTIVE"
        }
      ],
      "bodySite": {
        "code": "string",
        "system": "string",
        "display": "string"
      }
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none GenomicTests

Get test

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /genomics/projects/{projectId}/tests/{testId}

Get a genomic test for a project.

A genomic test represents a single sequencing event that has been added to the PHC. The resource contains metadata about the event like tissue body site information and dates when the test was collected. It contains the list of genomic sets that make up the test under the sets property.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
projectId path string true The project id.
testId path string true The test id.

Example responses

200 Response

{
  "id": "string",
  "datasetId": "string",
  "name": "string",
  "reportFileId": "string",
  "indexedDate": "2019-08-24T14:15:22Z",
  "createdDate": "2019-08-24T14:15:22Z",
  "testType": "string",
  "referenceSetId": "GRCh37",
  "msi": "string",
  "tmb": {
    "status": "string",
    "score": 0
  },
  "sourceFileId": "string",
  "patientId": "string",
  "status": "ACTIVE",
  "tasks": [
    "string"
  ],
  "sets": [
    {
      "id": "string",
      "name": "string",
      "setType": "shortVariant",
      "sequenceId": "string",
      "fileId": "string",
      "sequenceType": "somatic",
      "status": "ACTIVE"
    }
  ],
  "bodySite": {
    "code": "string",
    "system": "string",
    "display": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none GenomicTest

Delete test

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/genomics/projects/{projectId}/tests/{testId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /genomics/projects/{projectId}/tests/{testId}

Delete a genomic test for a project.

A genomic test represents a single sequencing event that has been added to the PHC. The resource contains metadata about the event like tissue body site information and dates when the test was collected. It contains the list of genomic sets that make up the test under the sets property.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
projectId path string true The project id.
testId path string true The test id.

Responses

Status Meaning Description Schema
204 No Content Gone None

Query expression data

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/genomics/expressions \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/expressions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/genomics/expressions', params={
  'rnaQuantificationSetIds': [
  null
]
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/expressions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/genomics/expressions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /genomics/expressions

Get gene expression data.

Returns a list of gene expression values from genomic expression sets.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
rnaQuantificationSetIds query array[any] true A list of genomic expression set IDs to restrict the results to. These IDs come from sets of type expression in a Genomic Test resource.
gene query array[any] false A list of genes to filter the structural variants by
outlierStdDev query string false A std dev value to filter expression data by
drugAssociations query boolean false True to filter variants by those with drug associations
include query string false Set to drugAssociations to include drug association records
pageSize query string false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Example responses

200 Response

{
  "items": [
    {
      "gene": "string",
      "expression": 0,
      "expressionUnit": "string",
      "stddev": 0,
      "min": 0,
      "max": 0,
      "avg": 0,
      "median": 0,
      "firstQuartile": 0,
      "thirdQuartile": 0,
      "drugAssociations": {
        "byGeneAndFeature": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ],
        "byGene": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ]
      }
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none ExpressionValues

Query copy number data

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/genomics/copy-number-variants \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/copy-number-variants',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/genomics/copy-number-variants', params={
  'copyNumberVariantSetIds': [
  null
]
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/copy-number-variants");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/genomics/copy-number-variants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /genomics/copy-number-variants

Get copy number variants.

Returns a list of copy number variants from genomic copy number variant sets.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
copyNumberVariantSetIds query array[any] true A list of genomic copy number variant set IDs to restrict the results to. These IDs come from sets of type copyNumberVariant in a Genomic Test resource.
gene query array[any] false A list of genes to filter the structural variants by
interpretation query string false A list of interpretation values to filter the copy number variants by
status query string false A list of status values to filter the copy number variants by
drugAssociations query boolean false True to filter variants by those with drug associations
include query string false Set to drugAssociations to include drug association records
pageSize query string false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "geneId": "string",
      "copyNumber": 0,
      "status": "string",
      "interpretation": "string",
      "chromosome": "string",
      "startPosition": 0,
      "endPosition": 0,
      "drugAssociations": {
        "byGeneAndFeature": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ],
        "byGene": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ]
      }
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none CopyNumberVariants

Query structural variant data

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/genomics/structural-variants \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/structural-variants',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/genomics/structural-variants', params={
  'structuralVariantSetIds': [
  null
]
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/structural-variants");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/genomics/structural-variants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /genomics/structural-variants

Get structural variants.

Returns a list of structural variants from genomic structural variant sets.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
structuralVariantSetIds query array[any] true A list of genomic structural variant set IDs to restrict the results to. These IDs come from sets of type structuralVariant in a Genomic Test resource.
gene query array[any] false A list of genes to filter the structural variants by
type query string false A list of type values to filter the structural variants by
interpretation query string false A list of interpretation values to filter the structural variants by
inFrame query string false A list of in frame values to filter the structural variants by
drugAssociations query boolean false True to filter variants by those with drug associations
include query string false Set to drugAssociations to include drug association records
pageSize query string false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Example responses

200 Response

{
  "items": [
    {
      "id": "string",
      "geneId1": "string",
      "geneId2": "string",
      "inFrame": "string",
      "type": "string",
      "interpretation": "string",
      "chromosome1": "string",
      "startPosition1": 0,
      "endPosition1": 0,
      "chromosome2": "string",
      "startPosition2": 0,
      "endPosition2": 0,
      "drugAssociations": {
        "byGeneAndFeature": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ],
        "byGene": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ]
      }
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none StructuralVariants

Query short variant data

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/genomics/variants \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/genomics/variants',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/genomics/variants', params={
  'variantSetIds': [
  null
]
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/genomics/variants");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/genomics/variants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /genomics/variants

Get short variants.

Returns a list of variants from genomic short variant sets.

Parameters

Name In Type Required Description
LifeOmic-Account header string true The LifeOmic account to access.
variantSetIds query array[any] true A list of genomic short variant set IDs to restrict the results to. These IDs come from sets of type shortVariant in a Genomic Test resource.
gene query array[any] false A list of genes to filter the variants by
rsid query array[any] false A list of rsID's to filter the variants by
chromosome query array[any] false A list of chromosomes to filter the variants by
clinvarAlleleId query array[any] false A list of ClinVar Ids to filter the variants by
clinvarDisease query array[any] false A list of ClinVar diseases to filter the variants by
clinvarReview query array[any] false A list of ClinVar review status values to filter the variants by
clinvarSignificance query array[any] false A list of ClinVar significance values to filter the variants by
cosmicId query array[any] false A list of COSMIC ID values to filter the variants by
cosmicStatus query array[any] false A list of COSMIC status values to filter the variants by
cosmicHistology query array[any] false A list of COSMIC histology values to filter the variants by
cosmicTumorSite query array[any] false A list of COSMIC tumor site values to filter the variants by
class query array[any] false A list of variant class values to filter the variants by
group query array[any] false A list of variant group values to filter the variants by
impact query array[any] false A list of variant impact values to filter the variants by
transcriptId query array[any] false A list of variant transcript ID values to filter the variants by
biotype query array[any] false A list of variant biotype values to filter the variants by
aminoAcidChange query array[any] false A list of variant amino acid change values to filter the variants by
sequenceType query array[any] false A list of variant sequence type values to filter the variants by
position query array[any] false A list of variant position values to filter the variants by
cosmicSampleCount query array[any] false A list of COSMIC sample count values to filter the variants by
minAlleleFrequency query array[any] false A list of min allele frequencey values to filter the variants by
maxAlleleFrequency query array[any] false A list of max allele frequency values to filter the variants by
popAlleleFrequency query array[any] false A list of population allele frequency values to filter the variants by
exacAlleleFrequency query array[any] false A list of EXAC allele frequency values to filter the variants by
exacHomozygous query array[any] false A list of EXAC homozygous values to filter the variants by
dbnsfpDamagingCount query array[any] false A list of DBNSFP damaging count values to filter the variants by
dbnsfpDamagingPredictor query array[any] false A list of DBNSFP damaging predictor values to filter the variants by
dbnsfpDamagingVote query array[any] false A list of DBNSFP damaging vote values to filter the variants by
dbnsfpFathmmRankscore query array[any] false A list of DBNSFP FATHMM rank score values to filter the variants by
dbnsfpFathmmPred query array[any] false A list of DBNSFP FATHMM pred values to filter the variants by
dbnsfpMeanRankscore query array[any] false A list of DBNSFP mean rank score values to filter the variants by
dbnsfpMeanRankscorePredictor query array[any] false A list of DBNSFP mean rank score predictor values to filter the variants by
dbnsfpMutationtasterRankscore query array[any] false A list of Mutation Taster rank score predictor values to filter the variants by
dbnsfpMutationtasterPred query array[any] false A list of Mutation Taster predictor values to filter the variants by
dbnsfpSiftRankscore query array[any] false A list of SIFT rank score values to filter the variants by
dbnsfpSiftPred query array[any] false A list of SIFT pred values to filter the variants by
zygosity query array[any] false A list of zygosity values to filter the variants by
genotype query array[any] false A list of genotype values to filter the variants by
variantAlleleFrequency query array[any] false A list of variant allele frequency values to filter the variants by
quality query array[any] false A list of VCF quality values to filter the variants by
readDepth query array[any] false A list of VCF read depth values to filter the variants by
altReadDepth query array[any] false A list of VCF alternate read depth values to filter the variants by
refReadDepth query array[any] false A list of VCF reference read depth values to filter the variants by
filter query array[any] false A list of VCF filter values to filter the variants by
drugAssociations query boolean false True to filter variants by those with drug associations
include query string false Set to drugAssociations to include drug association records
pageSize query number false The number of results to return in the request.
nextPageToken query string false The page token used to request a specific page.

Example responses

200 Response

{
  "items": [
    {
      "chromosome": "string",
      "reference": "string",
      "alternate": "string",
      "position": 0,
      "minimumAlleleFrequency": 0,
      "maximumAlleleFrequency": 0,
      "gnomadAlleleFrequency": 0,
      "gnomadHomozygous": "string",
      "rsid": "string",
      "drugAssociations": {
        "byGeneAndFeature": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ],
        "byGene": [
          {
            "feature": "string",
            "source": "string",
            "disease": "string",
            "gene": "string",
            "drug": "string",
            "responseType": "string",
            "evidenceLevel": "string",
            "sourceEvidence": "string",
            "publication": "string",
            "comment": "string"
          }
        ]
      },
      "clinvar": {
        "significance": "string",
        "alleleId": "string",
        "submission": "string",
        "disease": "string",
        "nearVariant": 0,
        "review": "string"
      },
      "ensemblCanon": [
        {
          "biotype": "string",
          "nucleotideChange": "string",
          "gene": "string",
          "geneId": "string",
          "impact": "string",
          "transcriptId": "string",
          "aminoAcidChange": "string",
          "class": "string",
          "exonIntronRank": "string",
          "group": "string",
          "hgvsAminoAcidChange": "string"
        }
      ],
      "cosmic": {
        "sampleCount": 0,
        "histology": "string",
        "tumorSite": "string",
        "nearVariant": 0,
        "cosmicId": "string",
        "status": "string"
      }
    }
  ],
  "links": {
    "self": "string",
    "next": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK none Variants

Ontologies

create-relationship

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships \
  -H 'Content-Type: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "equivalence": "relatedto",
  "source": {
    "type": "coding",
    "system": "string",
    "version": "string",
    "code": "string",
    "display": "string"
  },
  "target": {
    "type": "coding",
    "system": "string",
    "version": "string",
    "code": "string",
    "display": "string"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /terminology/projects/{project}/relationships

Creates a relationship

Creates a relationship.

Body parameter

{
  "equivalence": "relatedto",
  "source": {
    "type": "coding",
    "system": "string",
    "version": "string",
    "code": "string",
    "display": "string"
  },
  "target": {
    "type": "coding",
    "system": "string",
    "version": "string",
    "code": "string",
    "display": "string"
  }
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
body body Relationship false The relationship to create

Responses

Status Meaning Description Schema
201 Created Created None

create-relationships

Code samples

# You can also use wget
curl -X PATCH https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '[
  {
    "equivalence": "relatedto",
    "source": {
      "type": "coding",
      "system": "string",
      "version": "string",
      "code": "string",
      "display": "string"
    },
    "target": {
      "type": "coding",
      "system": "string",
      "version": "string",
      "code": "string",
      "display": "string"
    }
  }
]';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.patch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PATCH");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PATCH /terminology/projects/{project}/relationships

Creates many relationships

Creates many relationships.

Body parameter

[
  {
    "equivalence": "relatedto",
    "source": {
      "type": "coding",
      "system": "string",
      "version": "string",
      "code": "string",
      "display": "string"
    },
    "target": {
      "type": "coding",
      "system": "string",
      "version": "string",
      "code": "string",
      "display": "string"
    }
  }
]

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
body body array[object] false The relationships to create

Example responses

207 Response

[
  {
    "href": "string",
    "status": "string",
    "message": "string"
  }
]

Responses

Status Meaning Description Schema
207 Multi-Status Multi-Status Inline

Response Schema

Status Code 207

Name Type Required Restrictions Description
» href string false none A relative URL to the created relationship, if successful
» status string false none The HTTP status
» message string false none The HTTP status message

get-relationship

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /terminology/projects/{project}/relationships/{relationship}

Get a relationship

Get a relationship.

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
relationship path string true Relationship identifier

Example responses

200 Response

[
  {
    "equivalence": "relatedto",
    "source": {
      "type": "coding",
      "system": "string",
      "version": "string",
      "code": "string",
      "display": "string"
    },
    "target": {
      "type": "coding",
      "system": "string",
      "version": "string",
      "code": "string",
      "display": "string"
    }
  }
]

Responses

Status Meaning Description Schema
200 OK The relationship Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Relationship] false none none
» equivalence string false none The degree of equivalence between concepts.
» source any false none none

oneOf

Name Type Required Restrictions Description
»» anonymous any false none none

allOf

Name Type Required Restrictions Description
»»» anonymous object false none none
»»»» type string false none none

and

Name Type Required Restrictions Description
»»» anonymous Coding false none none
»»»» system string\ null false none
»»»» version string\ null false none
»»»» code string\ null false none
»»»» display string\ null false none

xor

Name Type Required Restrictions Description
»»» anonymous string(uuid) false none The source concept id

continued

Name Type Required Restrictions Description
»» target any false none none

oneOf

Name Type Required Restrictions Description
»»» anonymous any false none none

allOf

Name Type Required Restrictions Description
»»»» anonymous object false none none
»»»»» type string false none none

and

Name Type Required Restrictions Description
»»»» anonymous Coding false none none

xor

Name Type Required Restrictions Description
»»» anonymous string(uuid) false none The target concept id

Enumerated Values

Property Value
equivalence relatedto
equivalence equivalent
equivalence equal
equivalence wider
equivalence subsumes
equivalence narrower
equivalence specializes
equivalence inexact
equivalence unmatched
equivalence disjoint
type coding
type coding

delete-relationship

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship} \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/relationships/{relationship}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /terminology/projects/{project}/relationships/{relationship}

Delete a relationship

Delete a relationship.

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
relationship path string true Relationship identifier

Responses

Status Meaning Description Schema
200 OK ok None

create-coding

Code samples

# You can also use wget
curl -X POST https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/ \
  -H 'Content-Type: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');
const inputBody = '{
  "system": "string",
  "version": "string",
  "code": "string",
  "display": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Content-Type': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.post('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /terminology/projects/{project}/codings/

Creates a coding

Creates a coding.

Body parameter

{
  "system": "string",
  "version": "string",
  "code": "string",
  "display": "string"
}

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
body body Coding false The coding to create

Responses

Status Meaning Description Schema
201 Created Created None

get-codings

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/?system=string \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/?system=string',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'Accept': 'application/json',
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.get('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/', params={
  'system': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/?system=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /terminology/projects/{project}/codings/

Gets a collection of codings

Gets a collection of codings.

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
system query string true The identification of the code system that defines the meaning of the symbol in the code.
version query string false The version of the code system which was used when choosing this code.
code query string false A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination).
display query string false A representation of the meaning of the code in the system, following the rules of the system.

Example responses

200 Response

[
  {
    "system": "string",
    "version": "string",
    "code": "string",
    "display": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK The codings to create Inline

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Coding] false none none
» system string\ null false none
» version string\ null false none
» code string\ null false none
» display string\ null false none

delete-codings

Code samples

# You can also use wget
curl -X DELETE https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/?system=string \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/?system=string',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

import requests
headers = {
  'LifeOmic-Account': 'string',
  'Authorization': 'API_KEY'
}

r = requests.delete('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/', params={
  'system': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/?system=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "LifeOmic-Account": []string{"string"},
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /terminology/projects/{project}/codings/

Truncates a collection of codings

Deletes all matching codings. This operation cannot be undone.

Parameters

Name In Type Required Description
LifeOmic-Account header string true Assigned LifeOmic account
project path string true Target project identifier
system query string true The identification of the code system that defines the meaning of the symbol in the code.
version query string false The version of the code system which was used when choosing this code.
code query string false A symbol in syntax defined by the system. The symbol may be a predefined code or an expression in a syntax defined by the coding system (e.g. post-coordination).
display query string false A representation of the meaning of the code in the system, following the rules of the system.

Responses

Status Meaning Description Schema
200 OK ok None

get-coding

Code samples

# You can also use wget
curl -X GET https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/{coding} \
  -H 'Accept: application/json' \
  -H 'LifeOmic-Account: string' \
  -H 'Authorization: API_KEY'

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'LifeOmic-Account':'string',
  'Authorization':'API_KEY'

};

fetch('https://api.us.lifeomic.com/v1/terminology/projects/{project}/codings/{coding}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(fun