Gmelius API documentation

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

Gmelius API Overview

Welcome to the Gmelius API!

Gmelius offers a new way to collaborate, manage projects, and automate your workflows. The Gmelius API lets you easily create a functional application or integration around its two core resources for team collaboration: shared email conversations and kanban boards. Gmelius sequences are also available through our API.

Not a developer? Checkout our API presentation to learn what you can do with Gmelius thanks to a few common use cases.

How do I register?

Once logged in to our dashboard, head to your account page to get your API credentials.

Note 1: Access is for now restricted to our Growth and Enterprise plans. API credentials appear for admin and managers only. If you’d like to give our API a spin and see what it can or cannot do, contact our Success Team to request a trial: success@gmelius.com.

Note 2: Your API credentials solely allow access to the resources of your subscription.

API format

The Gmelius API is organized around REST and resource-oriented URLs. Our API uses standard HTTP response codes and methods.

API endpoints return JSON-encoded responses and accept JSON-encoded request bodies.

Except for authentication where the implemented framework OAuth 2.0 / OIDC deals with form-encoded request bodies.

Getting started

To get started with the Gmelius API, see the fully working code sample.

This small application performs OAuth 2.0 authentication and then displays a Gmelius board.

Authentication

Authentication is the process of verifying the identity of a user. In our case, it means a way to allow your third-party application to access Gmelius resources acting as a user logged in Gmelius.

Here is how it works. The process transforms your application credentials and a logged-in user into an access token and a refresh token. These tokens help you access the Gmelius API. The access token is used in the authentication header as a Bearer, the refresh token helps you create some new access tokens.

All the process of authentication is done with the protocol OAuth 2.0 and a layer on top of it called OpenID Connect 1.0. We will not go into details in these frameworks but we will outline some aspects below.

Let's say that OAuth 2.0 introduces an intermediary step of obtaining an authorization code. It is hence referred to as the authorization code flow. We clarify the parameters and the intermediary steps below.

Please note here that OAuth 2.0 also introduces a mechanism, called scope, to limit an application's access to specific resources.

We divide this section into five parts.

We describe the authorization code flow.
We explain how to refresh an access token that has a limited lifetime of one hour.
We detail scopes.
We reference some API endpoints related to authentication.
Finally, we give an example of an authentication process. If you are familiar with OAuth 2.0, this might be sufficient to get started.

Authorization code flow

We describe here the process of obtaining an access token and a refresh token from application credentials and a logged in user.

An intermediary step is included to obtain a so-called authorization code according to the following schema. This intermediary step is here for security reasons.

Get authorization code

The parameters are the following :

client_id is part of your credentials,
redirect_uri is the address where the authorization server will redirect to, giving the authorization_code as query parameter
scope is actually a list of scopes. Scopes restrict read-write access to specific resources (more on that in the next section). The list is separated by semi-colons. A specific scope offline_access is asked in both steps
code_challenge is the challenge string of PKCE (see below)
logged in Gmelius user on behalf of whom the application asks access.

Both redirect_uri and scope need to be allowed in your Gmelius API configuration page.

Include these parameters in the URL

https://gmelius.io/oauth/authorize?client_id=&redirect_uri=&code_challenge=&scope=

Redirect your user to this URL. Once the user is logged in, this will display the Gmelius consent screen where authorizes your application to access Gmelius resources on their behalf.

Once the user accepts, this will redirect to the redirect URI with the authorization code as a query parameter.

Get access token and refresh token

You are now able to exchange this authorization code for an access token and a refresh token.

In this request, both your application credentials client_id and client_secret are used for basic authentication. More precisely a request header field in the form of Authorization: Basic {client-header}, where client-header is the Base64 encoding of client_id and client_secret joined by a single colon :.

The code_verifier of PKCE also comes into place, see below.

For client-header=btoa(client_id+':'+client_secret)

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Authorization: Basic {client-header}'

POST https://api.gmelius.com/public/v2/token HTTP/1.1
Host: api.gmelius.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic {client-header}

const inputBody = '{
  "grant_type": "string",
  "code": "string",
  "scope": "string",
  "code_verifier": "string",
  "redirect_uri": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Authorization':'Basic {client-header}'
};

fetch('https://api.gmelius.com/public/v2/token',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/x-www-form-urlencoded',
  'Authorization' => 'Basic {client-header}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/token',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Authorization': 'Basic {client-header}'
}

r = requests.post('https://api.gmelius.com/public/v2/token', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic {client-header}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/token', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/token");
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/x-www-form-urlencoded"},
        "Authorization": []string{"Basic {client-header}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/token", data)
    req.Header = headers

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

POST /token

Body parameter

grant_type: string
code: string
scope: string
code_verifier: string
redirect_uri: string

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» grant_type	body	string	true	`authorization_code`
» code	body	string	true	Authorization code
» scope	body	string	true	`offline_access`
» code_verifier	body	string	true	Code verifier
» redirect_uri	body	string	true	Redirect URI

Example responses

200 Response

{
  "access_token": "pdwJR2Uq8BnTE5LGbtlqOxglfo03AEBU1xGDxhcm3bn",
  "expires_in": 3600,
  "refresh_token": "0p56iXbrZ7g5RiFL6euTW2X5AsVi9KmFHnIje0HOvDb",
  "scope": "offline_access https://api.gmelius.com/public/auth/conversations/metadata",
  "token_type": "Bearer"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

The HTTP response includes

access_token is the bearer used in HTTP calls to Gmelius resources. It has a limited lifetime of one hour.
refresh_token is used to produce a new access token with the same grant once the access token is expired. Note that refresh tokens also expire - after two months - and are renewed, see below.

PKCE

PKCE refers to Proof Key for Code Exchange. This technique allows to mitigate the threat of having the authorization code intercepted. It involves the client first creating a random secret code_verifier, and then using that secret again when exchanging the authorization code for an access token. This way if the code is intercepted, it will not be useful since the token request relies on the initial secret.

The value first sent when asking for an authorization code is not the code verifier but a hash of it code_challenge. The hashing method is S256: code challenge is a BASE64-URL-encoded string of the SHA256 hash of the code verifier.

code_challenge = base64url(createHash('sha256').update(code_verifier).digest())

Refreshing tokens

Refreshing access tokens

Access tokens have a limited lifetime of one hour for security reasons. In order to renew them, OAuth 2 gives a specific method described below.

Note that the renewal occurs with the same grant. This means the successive access tokens have the same rights, in particular the same scopes as when the user first clicked to authorize your third party application.

Access tokens are renewed with a specific token given at the end of the authorization code flow called a refresh token.

For client-header=btoa(client_id+':'+client_secret)

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Authorization: Basic {client-header}'

POST https://api.gmelius.com/public/v2/token HTTP/1.1
Host: api.gmelius.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic {client-header}

const inputBody = '{
  "grant_type": "string",
  "refresh_token": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Authorization':'Basic {client-header}'
};

fetch('https://api.gmelius.com/public/v2/token',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/x-www-form-urlencoded',
  'Authorization' => 'Basic {client-header}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/token',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Authorization': 'Basic {client-header}'
}

r = requests.post('https://api.gmelius.com/public/v2/token', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Authorization' => 'Basic {client-header}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/token', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/token");
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/x-www-form-urlencoded"},
        "Authorization": []string{"Basic {client-header}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/token", data)
    req.Header = headers

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

POST /token

Body parameter

grant_type: string
refresh_token: string

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» grant_type	body	string	true	`refresh_token`
» refresh_token	body	string	true	Refresh token

Example responses

200 Response

{
  "access_token": "pdwJR2Uq8BnTE5LGbtlqOxglfo03AEBU1xGDxhcm3bn",
  "expires_in": 3600,
  "scope": "offline_access https://api.gmelius.com/public/auth/conversations/metadata",
  "token_type": "Bearer"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Refreshing refresh tokens

A refresh token has a much longer lifetime of 60 days but also expires too. Upon first usage after half its lifetime, aka 30 days, the previous response will give a new refresh token. Be sure not to miss this singular response containing a new refresh token even if the first refresh token remains valid until the end of its lifetime.

Scopes

Scope is a mechanism in OAuth 2.0 to limit an application's access to a user's account. An application can request one or more scopes, this information is then presented to the user in the consent screen, and the access token issued to the application will be limited to the scopes granted.

Note that any scope asked for a user access token has to be allowed at the application level. Application level scopes are allowed in the Gmelius API configuration page.

List of Gmelius scopes

The list of Gmelius scopes is as follows:

Scope	Meaning
https://api.gmelius.com/public/auth/conversations/read	Read shared conversations for the user
https://api.gmelius.com/public/auth/conversations/metadata	Comment and modify status, ticketing, tags
https://api.gmelius.com/public/auth/conversations/insert	Send replies and send new emails
https://api.gmelius.com/public/auth/boards/read	Read Gmelius boards
https://api.gmelius.com/public/auth/boards/modify	Read and modify Gmelius boards
https://api.gmelius.com/public/auth/sequences/enroll	Read sequences and enroll

Offline access

An extra scope is present in the OAuth 2.0 process: the value offline_access.

It allows an access token to be obtained from a refresh token without user interaction.

It is also asked in both steps of the authorization code flow, see here.

Scope - API endpoint correspondence

We saw previously that any access token is tied with one or more scopes. And each scope allows access to a specific set of API endpoints. We make this correspondence clear in each of the Gmelius API endpoints documented below.

Quick example

This part gives a quick example and skips any explanations about parameters and steps. Read the previous part for explanations.

We use https://example.com as redirect_uri.
Moreover, we ask for just one scope https://api.gmelius.com/public/auth/boards/read. That is on top of the special scope offline_access, see below.
PKCE values code_verifier and code_challenge are as follows

code_verifier=testtesttesttesttesttesttesttesttesttesttesttest

which gives

code_challenge=lO_AJ2ilEcR6LRlckw86DAURi7qEDpnqarCj-C381Fw

Get authorization code

First, go to Gmelius consent screen:

GET https://gmelius.io/oauth/authorize?client_id={client_id}&redirect_uri=https://example.com&code_challenge=lO_AJ2ilEcR6LRlckw86DAURi7qEDpnqarCj-C381Fw&scope=offline_access;https://api.gmelius.com/public/auth/boards/read

You must replace client_id with your client ID.

This will give an authorization code in a URL :

https://example.com?code={code}

Get access token and refresh token

Next step is using this authorization code to obtain an access token and a refresh token. Use the HTTP call on the right :

For client-header=btoa(client_id+':'+client_secret)

curl --location --request POST 'https://api.gmelius.com/public/v2/token' \
--header 'Content-Type: application/x-www-form-urlencoded' \
--header 'Authorization: Basic {client-header}' \
--data-urlencode 'grant_type=authorization_code' \
--data-urlencode 'code={code}' \
--data-urlencode 'scope=offline_access' \
--data-urlencode 'code_verifier=testtesttesttesttesttesttesttesttesttesttesttest' \
--data-urlencode 'redirect_uri=https://example.com'

You must replace the code you just obtained. Also replace client-header which corresponds to basic authentication with client_id as username and client_secret as password.

This will give the following response containing your access token and refresh token.

{
    "access_token": "KxUk6Owx2Fhw221nmiWnm7fm9kH6V7a8NxlRTfttYes",
    "expires_in": 3600,
    "id_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImNscmU5NXBnYVFoeTZtNVBiSU8ybDUwV2s4T2FKYUg1NjJsNzZxZGlXdUkifQ.eyJzdWIiOiIwYTI1Yjg1NGFmZjhhYTZiNzFjOTBkMGRmMjFkNmUzOCIsImF0X2hhc2giOiI3RmhtU1h1ekUzWGk0X3VBYktWajNRIiwiYXVkIjoiYmZlYjkxN2E4ZDFkMjY3NjZhYmE5Mzc5YWVjYzk2MTQtNjlFcHg3WTJUZFF6YkpCdzE1b2hSLmdtZWxpdXMuY29tIiwiZXhwIjoxNjA0MDU1Njg0LCJpYXQiOjE2MDQwNTIwODQsImlzcyI6Imh0dHBzOi8vYXBpLmdtZWxpdXMuY29tL3B1YmxpYy92MSJ9.PbGZm354CBuXiRKeVUdblhEphhfZFNIl1fodzIil4ASFtp_6wsgcKaU-QdjsE94X40eudnaigMS-6BIc3CxnxJ3AVNhyYb0F9uqkVfNp6oRsrkxMMywdsCbxeSe_XfWMrDl4t2zzIB5nDjzJBsqje8JqtzDcj4Mxi-MXNgMbbVayZezkAw2Uvyfl8inL5y-eX-Ym92sICKtpZ9Qm2kNqh6gRlY4hJdkqyj_I1pcJkoxTDpXPsfurDh3mStPdOicHwtiU0FtRI_2DzOeAm4RJXirzm6rX-qzs4bWwMCvmtQOBOifnQjxRPe4D4-XIWsHPXpb-RcHUujVF50p8sHf-RA",
    "refresh_token": "PEPvFWZHUuJzyDJEUb8PUk3F02975ymiyxHxjpVy_p1",
    "scope": "openid offline_access https://api.gmelius.com/public/auth/boards/modify",
    "token_type": "Bearer"
}

Access protected resources

Using this access token as a bearer, you are now able to access Gmelius resources. More precisely, resources that just require reading boards and related metadata because the scope is https://api.gmelius.com/public/auth/boards/read.

For example, for listing boards, see here.

Boards

Access to boards

List all boards

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/boards \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/boards HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/boards',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/boards', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/boards', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/boards", data)
    req.Header = headers

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

GET /auth/boards

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": [
    {
      "kanban_board_id": "XyzUZidiUdujKJk",
      "user_id": "9babcdabcdabcd999abc",
      "board_name": "board name",
      "shared_folder_id": "shared folder id",
      "type": "gtd",
      "has_pending_subcategory": false,
      "calendar_id": "user@gmail.com",
      "owner": {
        "id": "4019106a8bc9516fd19ee54b77bbcd",
        "email": "john.doe@domain.com",
        "first_name": "John",
        "last_name": "Doe",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png"
      },
      "users": [
        {
          "user_id": "4019106a8bc9516fd19ee54b77bbcd",
          "email": "john.doe@domain.com",
          "first_name": "John",
          "last_name": "Doe",
          "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png",
          "approval": true
        }
      ]
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a board

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/boards \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/boards HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "type": "string",
  "group_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/boards',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/boards', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/boards', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/boards", data)
    req.Header = headers

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

POST /auth/boards

Body parameter

{
  "name": "string",
  "type": "string",
  "group_id": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» name	body	string	true	board name
» type	body	string	true	board type
» group_id	body	string	true	team linked to the board

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "kanban_board_id": "XyzUZidiUdujKJk",
    "user_id": "9babcdabcdabcd999abc",
    "board_name": "board name",
    "shared_folder_id": "shared folder id",
    "type": "gtd",
    "has_pending_subcategory": false,
    "calendar_id": "user@gmail.com",
    "owner": {
      "id": "4019106a8bc9516fd19ee54b77bbcd",
      "email": "john.doe@domain.com",
      "first_name": "John",
      "last_name": "Doe",
      "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png"
    },
    "users": [
      {
        "user_id": "4019106a8bc9516fd19ee54b77bbcd",
        "email": "john.doe@domain.com",
        "first_name": "John",
        "last_name": "Doe",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png",
        "approval": true
      }
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a board

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/boards/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/boards/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/boards/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/boards/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/boards/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/boards/{id}", data)
    req.Header = headers

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

GET /auth/boards/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	board id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "kanban_board_id": "XyzUZidiUdujKJk",
    "user_id": "9babcdabcdabcd999abc",
    "board_name": "board name",
    "shared_folder_id": "shared folder id",
    "type": "gtd",
    "has_pending_subcategory": false,
    "calendar_id": "user@gmail.com",
    "owner": {
      "id": "4019106a8bc9516fd19ee54b77bbcd",
      "email": "john.doe@domain.com",
      "first_name": "John",
      "last_name": "Doe",
      "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png"
    },
    "users": [
      {
        "user_id": "4019106a8bc9516fd19ee54b77bbcd",
        "email": "john.doe@domain.com",
        "first_name": "John",
        "last_name": "Doe",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png",
        "approval": true
      }
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Update a board

Code samples

# You can also use wget
curl -X PUT https://api.gmelius.com/public/v2/auth/boards/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v2/auth/boards/{id} HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.gmelius.com/public/v2/auth/boards/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.gmelius.com/public/v2/auth/boards/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.gmelius.com/public/v2/auth/boards/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/{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"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.gmelius.com/public/v2/auth/boards/{id}", data)
    req.Header = headers

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

PUT /auth/boards/{id}

Body parameter

{
  "name": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	board id
body	body	object	true	none
» name	body	string	true	board name

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "kanban_board_id": "XyzUZidiUdujKJk",
    "user_id": "9babcdabcdabcd999abc",
    "board_name": "board name",
    "shared_folder_id": "shared folder id",
    "type": "gtd",
    "has_pending_subcategory": false,
    "calendar_id": "user@gmail.com",
    "owner": {
      "id": "4019106a8bc9516fd19ee54b77bbcd",
      "email": "john.doe@domain.com",
      "first_name": "John",
      "last_name": "Doe",
      "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png"
    },
    "users": [
      {
        "user_id": "4019106a8bc9516fd19ee54b77bbcd",
        "email": "john.doe@domain.com",
        "first_name": "John",
        "last_name": "Doe",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://app.gmelius.com/assets/logo/color_100.png",
        "approval": true
      }
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Delete a board

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/boards/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/boards/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/boards/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/boards/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/boards/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/{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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/boards/{id}", data)
    req.Header = headers

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

DELETE /auth/boards/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	board id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Columns

Access to columns

List all board columns

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/boards/{id}/columns \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/boards/{id}/columns HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/{id}/columns',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/boards/{id}/columns',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/boards/{id}/columns', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/boards/{id}/columns', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/{id}/columns");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/boards/{id}/columns", data)
    req.Header = headers

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

GET /auth/boards/{id}/columns

Parameters

Name	In	Type	Required	Description
id	path	string	true	board id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": [
    {
      "column_id": "MTAxZ21lbGl1cw",
      "kanban_board_id": "NDRnbWVsaXVz",
      "column_name": "Inbox",
      "column_color": "white",
      "column_index": 0,
      "avatar_url": ""
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a column

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/boards/{id}/columns \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/boards/{id}/columns HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "column_index": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/{id}/columns',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/boards/{id}/columns',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/boards/{id}/columns', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/boards/{id}/columns', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/{id}/columns");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/boards/{id}/columns", data)
    req.Header = headers

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

POST /auth/boards/{id}/columns

Body parameter

{
  "name": "string",
  "column_index": 0
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	board id
body	body	object	true	none
» name	body	string	true	column name
» column_index	body	number	false	column index, if not given, the column is added as the last column

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "column_id": "MTAxZ21lbGl1cw",
    "kanban_board_id": "NDRnbWVsaXVz",
    "column_name": "Inbox",
    "column_color": "white",
    "column_index": 0,
    "avatar_url": ""
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a board column

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/boards/columns/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/boards/columns/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/columns/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/boards/columns/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/boards/columns/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/boards/columns/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/columns/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/boards/columns/{id}", data)
    req.Header = headers

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

GET /auth/boards/columns/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	column id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "column_id": "MTAxZ21lbGl1cw",
    "kanban_board_id": "NDRnbWVsaXVz",
    "column_name": "Inbox",
    "column_color": "white",
    "column_index": 0,
    "avatar_url": ""
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Update a column

Code samples

# You can also use wget
curl -X PATCH https://api.gmelius.com/public/v2/auth/boards/columns/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PATCH https://api.gmelius.com/public/v2/auth/boards/columns/{id} HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "column_index": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/columns/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.patch 'https://api.gmelius.com/public/v2/auth/boards/columns/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.patch('https://api.gmelius.com/public/v2/auth/boards/columns/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PATCH','https://api.gmelius.com/public/v2/auth/boards/columns/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/columns/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.gmelius.com/public/v2/auth/boards/columns/{id}", data)
    req.Header = headers

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

PATCH /auth/boards/columns/{id}

Body parameter

{
  "name": "string",
  "column_index": 0
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	column id
body	body	object	true	none
» name	body	string	false	new name
» column_index	body	number	false	new column index

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Delete a column

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/boards/columns/{id}?archiveCards=true \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/boards/columns/{id}?archiveCards=true HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/columns/{id}?archiveCards=true',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/boards/columns/{id}',
  params: {
  'archiveCards' => 'boolean'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/boards/columns/{id}', params={
  'archiveCards': 'true'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/boards/columns/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/columns/{id}?archiveCards=true");
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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/boards/columns/{id}", data)
    req.Header = headers

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

DELETE /auth/boards/columns/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	column id
archiveCards	query	boolean	true	archive cards when deleting the column

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "archived_card_ids": [
      "ab12f3",
      "a1b2f4",
      "a1b2c3"
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Cards

Access to cards

List all column cards

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/boards/columns/{id}/cards", data)
    req.Header = headers

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

GET /auth/boards/columns/{id}/cards

Parameters

Name	In	Type	Required	Description
id	path	string	true	column id
vri	query	number	false	vertical row index (0 or 1)
limit	query	number	false	pagination limit, defaults to 50
from	query	number	false	pagination start

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": [
    {
      "card_id": "MTMwMWdtZWxpdXM",
      "column_id": "MjMxZ21lbGl1cw",
      "kanban_board_id": "NTlnbWVsaXVz",
      "conversation_id": "MTAzOWdtZWxpdXM=",
      "tags": [
        {
          "tag_id": "MjRnbWVsaXVz",
          "name": "mytag",
          "color": "4392FA"
        }
      ],
      "card_index": 32768,
      "subject": "short description, subject",
      "snippet": "longer description, memo",
      "assignee": {
        "user_email": "test@gmail.com",
        "user_id": "718ffa1d7083ca3a7f0773d2b6b29961",
        "user_display_name": "john doe",
        "user_first_name": "john",
        "user_last_name": "doe"
      },
      "status": "open",
      "due_date": null,
      "created_at": 1616754284
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a board card

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/boards/cards/{id}?format=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/boards/cards/{id}?format=string HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/cards/{id}?format=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/boards/cards/{id}',
  params: {
  'format' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/boards/cards/{id}', params={
  'format': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/boards/cards/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/cards/{id}?format=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"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/boards/cards/{id}", data)
    req.Header = headers

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

GET /auth/boards/cards/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	card id
format	query	string	true	The format to return. Acceptable values are "minimal" (default) and "full" (with notes)

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "card_id": "MTMwMWdtZWxpdXM",
    "column_id": "MjMxZ21lbGl1cw",
    "kanban_board_id": "NTlnbWVsaXVz",
    "conversation_id": "MTAzOWdtZWxpdXM=",
    "tags": [
      {
        "tag_id": "MjRnbWVsaXVz",
        "name": "mytag",
        "color": "4392FA"
      }
    ],
    "card_index": 32768,
    "subject": "short description, subject",
    "snippet": "longer description, memo",
    "assignee": {
      "user_email": "test@gmail.com",
      "user_id": "718ffa1d7083ca3a7f0773d2b6b29961",
      "user_display_name": "john doe",
      "user_first_name": "john",
      "user_last_name": "doe"
    },
    "status": "open",
    "due_date": null,
    "created_at": 1616754284
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Update a card

Code samples

# You can also use wget
curl -X PATCH https://api.gmelius.com/public/v2/auth/boards/cards/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PATCH https://api.gmelius.com/public/v2/auth/boards/cards/{id} HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "subject": "string",
  "snippet": "string",
  "due_date": 0,
  "status": "string",
  "assignee_email": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/cards/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.patch 'https://api.gmelius.com/public/v2/auth/boards/cards/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.patch('https://api.gmelius.com/public/v2/auth/boards/cards/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PATCH','https://api.gmelius.com/public/v2/auth/boards/cards/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/cards/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.gmelius.com/public/v2/auth/boards/cards/{id}", data)
    req.Header = headers

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

PATCH /auth/boards/cards/{id}

Body parameter

{
  "subject": "string",
  "snippet": "string",
  "due_date": 0,
  "status": "string",
  "assignee_email": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	card id
body	body	object	true	none
» subject	body	string	false	(top of card)
» snippet	body	string	false	(body)
» due_date	body	number	false	due date of the card
» status	body	string	false	possible values : 'open', 'pending', 'closed'
» assignee_email	body	string	false	Assignee email - null to unassign

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": [
    {
      "card_id": "MTMwMWdtZWxpdXM",
      "column_id": "MjMxZ21lbGl1cw",
      "kanban_board_id": "NTlnbWVsaXVz",
      "conversation_id": "MTAzOWdtZWxpdXM=",
      "tags": [
        {
          "tag_id": "MjRnbWVsaXVz",
          "name": "mytag",
          "color": "4392FA"
        }
      ],
      "card_index": 32768,
      "subject": "short description, subject",
      "snippet": "longer description, memo",
      "assignee": {
        "user_email": "test@gmail.com",
        "user_id": "718ffa1d7083ca3a7f0773d2b6b29961",
        "user_display_name": "john doe",
        "user_first_name": "john",
        "user_last_name": "doe"
      },
      "status": "open",
      "due_date": null,
      "created_at": 1616754284
    }
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Delete a card

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/boards/cards/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/boards/cards/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/cards/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/boards/cards/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/boards/cards/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/boards/cards/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/cards/{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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/boards/cards/{id}", data)
    req.Header = headers

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

DELETE /auth/boards/cards/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	card id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a card

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/boards/cards \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/boards/cards HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "column_id": "string",
  "subject": "string",
  "snippet": "string",
  "due_date": 0,
  "insert_at_end": true,
  "create_conversation": true,
  "rfc_message_id": "string",
  "card_index": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/cards',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/boards/cards',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/boards/cards', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/boards/cards', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/cards");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/boards/cards", data)
    req.Header = headers

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

POST /auth/boards/cards

Body parameter

{
  "column_id": "string",
  "subject": "string",
  "snippet": "string",
  "due_date": 0,
  "insert_at_end": true,
  "create_conversation": true,
  "rfc_message_id": "string",
  "card_index": 0
}

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» column_id	body	string	true	id the column in which to insert the card
» subject	body	string	true	top of the card
» snippet	body	string	true	body
» due_date	body	number	false	due date
» insert_at_end	body	boolean	false	none
» create_conversation	body	boolean	false	create a new gmail conversation with this new card
» rfc_message_id	body	string	false	Message id that will be set with the conversation associated to the card
» card_index	body	number	false	desired insert index

Example responses

200 Response

{
  "meta": {
    "status": 201,
    "code": "Created"
  },
  "data": {
    "column_id": "NWdtZWxpdXM",
    "card_id": "MTMxMGdtZWxpdXM",
    "kanban_board_id": "MmdtZWxpdXM",
    "conversation_id": null,
    "tags": [],
    "card_index": 65536,
    "subject": "my subject",
    "snippet": "my snippet",
    "assignee": null,
    "status": "open",
    "due_date": null,
    "created_at": 1617120827
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a tag on a card

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "color": "string",
  "tag_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags", data)
    req.Header = headers

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

POST /auth/boards/cards/{id}/tags

Body parameter

{
  "name": "string",
  "color": "string",
  "tag_id": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	card id
body	body	object	true	none
» name	body	string	false	if present, it will create a new tag and apply it on the card. If not, tag_id is required
» color	body	string	false	tag color if new tag is created
» tag_id	body	string	false	if present, apply this existing tag to the card

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "tag_id": "OWdtZWxpdXM=",
    "name": "mytag",
    "color": "4392FA"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Delete a tag on a card

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/boards/cards/{id}/tags/{tag_id}", data)
    req.Header = headers

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

DELETE /auth/boards/cards/{id}/tags/{tag_id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	card id
tag_id	path	string	true	tag id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Shared Folders

Access to shared folders

List all shared folders of a specific user

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/sharedfolders \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/sharedfolders HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sharedfolders',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/sharedfolders',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/sharedfolders', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/sharedfolders', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sharedfolders");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/sharedfolders", data)
    req.Header = headers

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

GET /auth/sharedfolders

Parameters

Name	In	Type	Required	Description
limit	query	number	false	pagination limit, defaults to 50
from	query	number	false	pagination start
q	query	string	false	filters the result by name using the string specified in the parameter
include	query	string	false	(default owned, can be owned or linked) Allows you to list only the shared folders that the user owns or all the shared folders linked to him

Example responses

200 Response

{
  "data": {
    "shared_folders": [
      {
        "shared_folder_id": "MTM1Z21lbGl1cw==",
        "name": "Sharedd label 1",
        "shared_inbox": true,
        "created_at": 1605120904,
        "owner": "john.doe@gmail.com",
        "shared_with_users": [
          {
            "email": "john.doe@gmail.com",
            "approval": "approved"
          },
          {
            "email": "john.doe2@gmail.com",
            "approval": "pending"
          }
        ]
      },
      {
        "shared_folder_id": "MTM2Z21lbGl1cw==",
        "name": "My GTD board",
        "shared_inbox": false,
        "created_at": 1605784078,
        "owner": "john.doe2@gmail.com",
        "shared_with_users": [
          {
            "email": "john.doe2@gmail.com",
            "approval": "approved"
          },
          {
            "email": "john.doe@gmail.com",
            "approval": "approved"
          }
        ]
      }
    ],
    "total_count": 2
  },
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a shared folder

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/sharedfolders/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/sharedfolders/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sharedfolders/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/sharedfolders/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/sharedfolders/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/sharedfolders/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sharedfolders/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/sharedfolders/{id}", data)
    req.Header = headers

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

GET /auth/sharedfolders/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	The folder (shared inbox or shared label) to be listed

Example responses

200 Response

{
  "data": {
    "shared_folder_id": "MTM2Z21lbGl1cw==",
    "name": "My GTD board",
    "shared_inbox": false,
    "created_at": 1605784078,
    "owner": "john.doe2@gmail.com",
    "shared_with_users": [
      {
        "user_email": "john.doe2@gmail.com",
        "approval": "approved"
      },
      {
        "user_email": "john.doe@gmail.com",
        "approval": "approved"
      }
    ]
  },
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Conversations

Access to conversations

List all conversations of a shared folder

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/sharedfolders/{id}/conversations", data)
    req.Header = headers

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

GET /auth/sharedfolders/{id}/conversations

Parameters

Name	In	Type	Required	Description
id	path	string	true	The folder (shared inbox or shared label) to be listed
limit	query	number	false	pagination limit, defaults to 50
page_token	query	string	false	query parameter to fill with the result `next_page_token` of the previous page

Example responses

200 Response

{
  "data": {
    "conversations": [
      {
        "conversation_id": "NDAxZ21lbGl1cw==",
        "subject": "My shared email",
        "thread_id": "175e02daf08dc789",
        "status": "open",
        "assignee": {
          "user_email": "john.doe@gmail.com",
          "user_name": "john doe",
          "user_first_name": "john",
          "user_last_name": "doe",
          "user_id": "bfa95f525c4adc45ee8fecf97695e5b3"
        },
        "tags": [
          {
            "tag_id": "OGdtZWxpdXM=",
            "name": "important",
            "color": "61bd57"
          }
        ]
      }
    ],
    "nextPageToken": "ae35e838e07e36c715162cdf26b575c1df15ed"
  },
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a conversation

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/conversations/{id}?format=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/conversations/{id}?format=string HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}?format=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/conversations/{id}',
  params: {
  'format' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/conversations/{id}', params={
  'format': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/conversations/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}?format=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"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/conversations/{id}", data)
    req.Header = headers

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

GET /auth/conversations/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation id
format	query	string	true	The format to return. Acceptable values are "minimal" (default) and "full" (with messages and notes)

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "conversation_id": "MTAwNmdtZWxpdXM",
    "users": [
      {
        "user_id": "bfa95f525c4adc45ee8fecf97695e5b3",
        "user_email": "bernard@gmail.com",
        "user_first_name": "bernard",
        "user_last_name": "brown",
        "user_display_name": "bernard brown"
      },
      {
        "user_id": "718ffa1d7083ca3a7f0773d2b6b29961",
        "user_email": "alan@gmail.com",
        "user_first_name": "alan",
        "user_last_name": "amsted",
        "user_display_name": "alan amsted"
      }
    ],
    "status": "open",
    "assignee": {
      "user_id": "bfa95f525c4adc45ee8fecf97695e5b3",
      "user_email": "john.dow@gmail.com",
      "user_first_name": "john",
      "user_last_name": "dow",
      "user_display_name": "john dow"
    },
    "thread_id": "1723324a5d0c9729",
    "subject": "mysubject",
    "tags": [
      {
        "tag_id": "OGdtZWxpdXM=",
        "name": "important",
        "color": "61bd57"
      }
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a note on a conversation

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/conversations/{id}/notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/conversations/{id}/notes HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "note": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}/notes',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/conversations/{id}/notes',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/conversations/{id}/notes', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/conversations/{id}/notes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}/notes");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/conversations/{id}/notes", data)
    req.Header = headers

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

POST /auth/conversations/{id}/notes

Body parameter

{
  "note": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation id where the note should be added
body	body	object	true	none
» note	body	string	true	Content of the note

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Reply to a conversation

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/conversations/{id}/reply \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/conversations/{id}/reply HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "content": "string",
  "reply_all": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}/reply',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/conversations/{id}/reply',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/conversations/{id}/reply', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/conversations/{id}/reply', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}/reply");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/conversations/{id}/reply", data)
    req.Header = headers

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

POST /auth/conversations/{id}/reply

Body parameter

{
  "content": "string",
  "reply_all": true
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation to reply to
body	body	object	true	none
» content	body	string	true	Email content
» reply_all	body	boolean	true	Reply to all or not

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a draft on a conversation

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/conversations/{id}/draft \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/conversations/{id}/draft HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "content": "string",
  "is_shared": true,
  "reply_all": true,
  "ref_message_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}/draft',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/conversations/{id}/draft',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/conversations/{id}/draft', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/conversations/{id}/draft', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}/draft");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/conversations/{id}/draft", data)
    req.Header = headers

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

POST /auth/conversations/{id}/draft

Body parameter

{
  "content": "string",
  "is_shared": true,
  "reply_all": true,
  "ref_message_id": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation to reply to
body	body	object	true	none
» content	body	string	true	Draft content
» is_shared	body	boolean	true	Whether draft is shared or not
» reply_all	body	boolean	true	Reply to all or not
» ref_message_id	body	string	false	If present, message id to reply to - default is last message

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a tag on a conversation

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/conversations/{id}/tags \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/conversations/{id}/tags HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "tag_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}/tags',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/conversations/{id}/tags',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/conversations/{id}/tags', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/conversations/{id}/tags', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}/tags");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/conversations/{id}/tags", data)
    req.Header = headers

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

POST /auth/conversations/{id}/tags

Body parameter

{
  "name": "string",
  "tag_id": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation id where the tag should be added
body	body	object	true	none
» name	body	string	false	if present, it will create a new tag and apply it on the card. If not, tag_id is required
» tag_id	body	string	false	if present, apply this existing tag to the card

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Assign a conversation

Code samples

# You can also use wget
curl -X PUT https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "assignee_email": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee");
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"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.gmelius.com/public/v2/auth/conversations/{id}/assignee", data)
    req.Header = headers

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

PUT /auth/conversations/{id}/assignee

Body parameter

{
  "assignee_email": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation id
body	body	object	true	none
» assignee_email	body	string	true	Assignee email - null to unassign

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Update status of a conversation

Code samples

# You can also use wget
curl -X PUT https://api.gmelius.com/public/v2/auth/conversations/{id}/status \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v2/auth/conversations/{id}/status HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "status": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/conversations/{id}/status',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.gmelius.com/public/v2/auth/conversations/{id}/status',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.gmelius.com/public/v2/auth/conversations/{id}/status', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.gmelius.com/public/v2/auth/conversations/{id}/status', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/conversations/{id}/status");
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"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.gmelius.com/public/v2/auth/conversations/{id}/status", data)
    req.Header = headers

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

PUT /auth/conversations/{id}/status

Body parameter

{
  "status": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Conversation id
body	body	object	true	none
» status	body	string	true	Can be either ["closed", "pending", "open"]

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Sequences

Access to sequences

List all user sequences

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/sequences \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/sequences HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sequences',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/sequences',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/sequences', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/sequences', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sequences");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/sequences", data)
    req.Header = headers

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

GET /auth/sequences

Parameters

Name	In	Type	Required	Description
limit	query	number	false	pagination limit, defaults to 50
from	query	number	false	pagination start
q	query	string	false	filters the result by name using the string specified in the parameter

Example responses

200 Response

{
  "data": {
    "sequences": [
      {
        "sequence_id": "OGdtZWxpdXM=",
        "name": "seq1",
        "is_active": false,
        "created_at": 1582277281,
        "updated_at": 1583744974,
        "email": "dev1@gmail.com",
        "multiple_time_same_sequence": true,
        "end_after_reply": false,
        "one_sequence_at_a_time": false,
        "insert_replies": true,
        "working_days": false,
        "unsubscribe_link": false,
        "is_read_only": false,
        "shared_users": [
          {
            "id": "bfa95f525c4adc45ee8fecf97695e5b3",
            "email": "dev2@gmail.com",
            "display_name": "bernard brown",
            "photo_url": "https://cloud.gmelius.com/public/users/bfa95f525c4adc45ee8fecf97695e5b3.png?1582107887"
          }
        ]
      },
      {
        "sequence_id": "NDJnbWVsaXVz",
        "name": "seq2",
        "is_active": false,
        "created_at": 1583742057,
        "updated_at": 1583745042,
        "email": "dev1@gmail.com",
        "multiple_time_same_sequence": true,
        "end_after_reply": false,
        "one_sequence_at_a_time": false,
        "insert_replies": true,
        "working_days": false,
        "unsubscribe_link": false,
        "is_read_only": false,
        "shared_users": []
      }
    ],
    "total_count": 2
  },
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a sequence

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/sequences/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/sequences/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sequences/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/sequences/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/sequences/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/sequences/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sequences/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/sequences/{id}", data)
    req.Header = headers

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

GET /auth/sequences/{id}

Parameters

Name	In	Type	Required	Description
id	path	number	true	sequence id

Example responses

200 Response

{
  "data": {
    "sequence_id": "NDJnbWVsaXVz",
    "name": "seq2",
    "is_active": false,
    "created_at": 1583742057,
    "updated_at": 1583745042,
    "email": "dev1@gmail.com",
    "multiple_time_same_sequence": true,
    "end_after_reply": false,
    "one_sequence_at_a_time": false,
    "insert_replies": true,
    "working_days": false,
    "unsubscribe_link": false,
    "is_read_only": false,
    "shared_users": [],
    "variables": [
      "my_variable"
    ]
  },
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Enroll user in sequence

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/sequences/enroll/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/sequences/enroll/{id} HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "email_address": "string",
  "name": "string",
  "variables": [
    {
      "name": "string",
      "value": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sequences/enroll/{id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/sequences/enroll/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/sequences/enroll/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/sequences/enroll/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sequences/enroll/{id}");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/sequences/enroll/{id}", data)
    req.Header = headers

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

POST /auth/sequences/enroll/{id}

Body parameter

{
  "email_address": "string",
  "name": "string",
  "variables": [
    {
      "name": "string",
      "value": "string"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Sequence id
body	body	object	true	none
» email_address	body	string	true	recipient email
» name	body	string	false	recipient name
» variables	body	[SequenceVariable]	false	none
»» name	body	string	false	name
»» value	body	string	false	value

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Disenroll user from sequence

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}?email_address=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}?email_address=string HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}?email_address=string',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}',
  params: {
  'email_address' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}', params={
  'email_address': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}?email_address=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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/sequences/disenroll/{id}", data)
    req.Header = headers

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

DELETE /auth/sequences/disenroll/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Sequence id
email_address	query	string	true	recipient email

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Metadata

Access to metadata

Create a note

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/notes HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "thread_id": "string",
  "card_id": "string",
  "body": "string",
  "user_full_name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/notes',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/notes',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/notes', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/notes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/notes");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/notes", data)
    req.Header = headers

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

POST /auth/notes

Body parameter

{
  "thread_id": "string",
  "card_id": "string",
  "body": "string",
  "user_full_name": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» thread_id	body	string	false	gmail's thread_id, if not present, card_id should be filled
» card_id	body	string	false	card id, if not present, thread_id should be filled
» body	body	string	true	body
» user_full_name	body	string	false	allows matching the user full name for determining the note author, only works if the user is part of the subscription of the request's user

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "key": 42
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Update a note

Code samples

# You can also use wget
curl -X PUT https://api.gmelius.com/public/v2/auth/notes/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v2/auth/notes/{id} HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "body": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/notes/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.gmelius.com/public/v2/auth/notes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.gmelius.com/public/v2/auth/notes/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.gmelius.com/public/v2/auth/notes/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/notes/{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"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.gmelius.com/public/v2/auth/notes/{id}", data)
    req.Header = headers

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

PUT /auth/notes/{id}

Body parameter

{
  "body": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	number	true	The id of the note
body	body	object	true	none
» body	body	string	true	body

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {}
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Delete a note

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/notes/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/notes/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/notes/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/notes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/notes/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/notes/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/notes/{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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/notes/{id}", data)
    req.Header = headers

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

DELETE /auth/notes/{id}

Parameters

Name	In	Type	Required	Description
id	path	number	true	The id of the note

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Update a tag

Code samples

# You can also use wget
curl -X PATCH https://api.gmelius.com/public/v2/auth/tags/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PATCH https://api.gmelius.com/public/v2/auth/tags/{id} HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "name": "string",
  "color": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/tags/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.patch 'https://api.gmelius.com/public/v2/auth/tags/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.patch('https://api.gmelius.com/public/v2/auth/tags/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PATCH','https://api.gmelius.com/public/v2/auth/tags/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/tags/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "https://api.gmelius.com/public/v2/auth/tags/{id}", data)
    req.Header = headers

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

PATCH /auth/tags/{id}

Body parameter

{
  "name": "string",
  "color": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	tag id
body	body	object	true	none
» name	body	string	false	tag name
» color	body	string	false	tag color

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Webhooks

Access to webhooks

Webhooks details

Webhooks provide a way to monitor changes happening in Gmelius.

Creation

Gmelius needs a callback URL to send webhooks to. Gmelius will do a HTTP POST request to the callback URL whenever data changes in Gmelius for the subscribed model.

The provided callback URL must be a valid URL during the creation of the webhook. A HTTP HEAD request will be performed. If a standard HTTP 200 (ok) response is not returned, then the webhook will not be created.

Get a token by authorizing with OAuth 2.0
POST https://api.gmelius.com/public/v2/auth/webhooks with the following example body on the right.

{
  "type": "board",
  "model_id": "WszxMnsZuwMWdH"
  "description": "My webhook 1"
  "callback_url": "https://api.mycompany.com/callback"
  "valid_until": "60"
}

curl --location --request POST 'https://api.gmelius.com/public/v2/auth/webhooks' </span>
--header 'Authorization: Bearer {bearer-token}' </span>
--header 'Content-Type: application/json' </span>
--data-raw '{"type": "board", "model_id": "WszxMnsZuwMWdH","description": "My webhook 1","callback_url": "https://api.mycompany.com/callback","valid_until": "60" }'

Deletion

Deletion of a webhook can be performed in the following ways :

Using the DELETE route on webhooks
By deleting subscribed model
By deleting the user
By revoking the associated token

Webhook Signatures

Gmelius signs webhook requests so you can optionally verify that they actually originated from Gmelius.

Each webhook trigger contains the HTTP header X-Gmelius-Webhook.

The header is a RS256 JWT containing a base64 digest of a SHA256 hash, along with the callback URL defined at the creation of the webhook

Event types

event type	description
board_update	when a setting of a board has changed
board_delete	when a board is deleted
create_card	when a card is created on a board
delete_card	when a card is deleted on a board
update_card	when a card is updated on a board
create_column	when a column is created on a board
update_column	when a column is updated on a board
delete_column	when a column is deleted on a board
delete_webhook	when a webhook is deleted
create_card_note	when a note is created on a card
update_card_note	when a note is updated on a card
delete_card_note	when a note is deleted from a card
create_conversation	when a conversation is created
create_conversation_message	when a reply is added to a conversation
create_conversation_note	when a note is created on a conversation
delete_conversation_note	when a note is deleted on a conversation
update_conversation	when a conversation is updated
update_tag	when a tag is updated (its name can be changed)
delete_tag	when a tag is completely deleted from Gmelius subscription
action_executed	when a sequence action is executed
disenroll	when a user is disenrolled from a sequence

Retries

A webhook request may be retried 100 times at max, at a minimum interval of 0.1 seconds, and a maximum interval of 3600 seconds.

The interval between retries is doubled 16 times at max. before the increase becomes constant.

This means that, the first retry interval will be 0.1 * 2^1 = 0.2, and so on up to 0.1 * 2^15 = 3276.8, the 16th time being 3600 seconds. Subsequent retries will be done at a 3600 seconds interval until a retry count of 100 is reached.

Thus, a webhook may be retried during 3 days at maximum.

List all grant webhooks

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/webhooks \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/webhooks HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/webhooks',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/webhooks',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/webhooks', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/webhooks', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/webhooks");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/webhooks", data)
    req.Header = headers

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

GET /auth/webhooks

Parameters

Name	In	Type	Required	Description
limit	query	number	false	pagination limit, defaults to 50
from	query	number	false	pagination start

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "webhooks": [
      {
        "webhook_id": "XmwuuruHDIeIXW",
        "user_id": "XdxieieridjdwW",
        "type": "board",
        "model_id": "XmUiKXoiWjCW",
        "callback_url": "https://callbackurl.com/callback",
        "active": true,
        "last_success": 1602508000,
        "valid_until": 60
      }
    ],
    "total_count": 1
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Create a webhook

Code samples

# You can also use wget
curl -X POST https://api.gmelius.com/public/v2/auth/webhooks \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v2/auth/webhooks HTTP/1.1
Host: api.gmelius.com
Content-Type: application/json
Accept: application/json

const inputBody = '{
  "type": "string",
  "model_id": "string",
  "description": "string",
  "callback_url": "string",
  "valid_until": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/webhooks',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.gmelius.com/public/v2/auth/webhooks',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.gmelius.com/public/v2/auth/webhooks', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.gmelius.com/public/v2/auth/webhooks', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/webhooks");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.gmelius.com/public/v2/auth/webhooks", data)
    req.Header = headers

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

POST /auth/webhooks

Body parameter

{
  "type": "string",
  "model_id": "string",
  "description": "string",
  "callback_url": "string",
  "valid_until": 0
}

Parameters

Name	In	Type	Required	Description
body	body	object	true	none
» type	body	string	true	can be 'board' or 'shared_folder' or 'sequence'
» model_id	body	string	true	the model to listen to, either boardId or sharedLabelId or sequenceId
» description	body	string	false	description
» callback_url	body	string	true	callback url to trigger
» valid_until	body	number	true	number of seconds the webhook payload is valid

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "webhook_id": "XmwuuruHDIeIXW",
    "user_id": "XdxieieridjdwW",
    "type": "board",
    "model_id": "XmUiKXoiWjCW",
    "callback_url": "https://callbackurl.com/callback",
    "active": true,
    "last_success": 1602508000,
    "valid_until": 60
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

List all events of a webhook

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/events?id=string&model_type=string&model_id=string&before=0&since=0&offset=0&limit=0 \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/events?id=string&model_type=string&model_id=string&before=0&since=0&offset=0&limit=0 HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/events?id=string&model_type=string&model_id=string&before=0&since=0&offset=0&limit=0',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/events',
  params: {
  'id' => 'string',
'model_type' => 'string',
'model_id' => 'string',
'before' => 'number',
'since' => 'number',
'offset' => 'number',
'limit' => 'number'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/events', params={
  'id': 'string',  'model_type': 'string',  'model_id': 'string',  'before': '0',  'since': '0',  'offset': '0',  'limit': '0'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/events', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/events?id=string&model_type=string&model_id=string&before=0&since=0&offset=0&limit=0");
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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/events", data)
    req.Header = headers

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

GET /auth/events

Parameters

Name	In	Type	Required	Description
id	query	string	true	webhook id
model_type	query	string	true	eg. board
model_id	query	string	true	eg. id of a board
before	query	number	true	unix timestamp (seconds)
since	query	number	true	unix timestamp (seconds)
offset	query	number	true	pagination offset
limit	query	number	true	pagination limit

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "hook_id": "XmwwmsxcmnWmM",
    "created_at": 1602508000,
    "type": "create_card",
    "model_type": "board",
    "model_id": "XmwxmdxCwMdXM",
    "events": [
      {
        "previousAttributes": {
          "subject": "old subject",
          "snippet": "old snippet"
        },
        "card": {
          "subject": "old snippet",
          "snippet": "new snippet"
        }
      }
    ]
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Get a webhook

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v2/auth/webhooks/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v2/auth/webhooks/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/webhooks/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.gmelius.com/public/v2/auth/webhooks/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.gmelius.com/public/v2/auth/webhooks/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.gmelius.com/public/v2/auth/webhooks/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/webhooks/{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{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.gmelius.com/public/v2/auth/webhooks/{id}", data)
    req.Header = headers

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

GET /auth/webhooks/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	id webhook id

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "webhook_id": "XmwuuruHDIeIXW",
    "user_id": "XdxieieridjdwW",
    "type": "board",
    "model_id": "XmUiKXoiWjCW",
    "callback_url": "https://callbackurl.com/callback",
    "active": true,
    "last_success": 1602508000,
    "valid_until": 60
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Delete a webhook

Code samples

# You can also use wget
curl -X DELETE https://api.gmelius.com/public/v2/auth/webhooks/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v2/auth/webhooks/{id} HTTP/1.1
Host: api.gmelius.com
Accept: application/json


const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v2/auth/webhooks/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.delete 'https://api.gmelius.com/public/v2/auth/webhooks/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.gmelius.com/public/v2/auth/webhooks/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.gmelius.com/public/v2/auth/webhooks/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.gmelius.com/public/v2/auth/webhooks/{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{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.gmelius.com/public/v2/auth/webhooks/{id}", data)
    req.Header = headers

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

DELETE /auth/webhooks/{id}

Parameters

Name	In	Type	Required	Description
id	path	string	true	id of the webhook to delete

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Response Schema

Schemas

Be careful on deserialization on these objects because they might contain additional properties in future versions of Gmelius API. You may ignore unkown properties, e.g. in Java with the annotation

@JsonIgnoreProperties(ignoreUnknown = true)

Board

{ "kanban_board_id": "string", "user_id": "string", "board_name": "string", "shared_folder_id": "string", "type": "string", "has_pending_subcategory": true, "calendar_id": "string", "owner": { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true }, "users": [ { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true } ] }

Properties

Name	Type	Description
kanban_board_id	string	board id
user_id	string	user id
board_name	string	board name
shared_folder_id	string	Gmelius shared label id the board is linked to
type	string	possible values : ticketing, gtd, inbox, custom
has_pending_subcategory	boolean	does the board have a pending sub-category
calendar_id	string	google calendar's id, can be null
owner	User	board owner
users	[User]	board users

Card

{ "card_id": "string", "card_index": "string", "priority": "string", "owner_id": "string", "subject": "string", "snippet": "string", "sender": "string", "sender_name": "string", "calendar_id": "string", "calendar_event_id": "string", "sent_date": 0, "thread_id": "string", "column_id": "string", "due_date": 0, "total_tasks": 0, "completed_tasks": 0, "vertical_row_index": 0, "conversation_id": "string", "shared_folders": [ { "shared_folder_id": "string", "name": "string", "shared_inbox": true, "created_at": 0, "owner": "string", "shared_with_users": [ { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true } ] } ], "assignee_id": "string", "status": "string", "message_id": "string", "notes_count": 0, "tags": [ { "tag_id": "string", "name": "string", "color": "string" } ], "notes": [ { "user_id": "string", "note_id": 0, "thread_id": "string", "message_id": "string", "first_name": "string", "last_name": "string", "email": "string", "picture_url": "string", "body": "string", "created": 0 } ], "updated_at": 0 }

Properties

Name	Type	Description
card_id	string	card id
card_index	string	card index
priority	string	priority
owner_id	string	owner id
subject	string	short description
snippet	string	long description
sender	string	sender email
sender_name	string	sender name
calendar_id	string	gmail id of calendar, typically user@gmail.com
calendar_event_id	string	corresponding event id in the calendar
sent_date	number	creation date of the card
thread_id	string	if the card is linked to a gmail conversation, gmail thread id
column_id	string	id of the column the card belongs to
due_date	number	due date of the card
total_tasks	number	number of tasks belonging to the card
completed_tasks	number	number of tasks completed
vertical_row_index	number	0 = normal sub-category, 1 = pending sub-category
conversation_id	string	conversation id
shared_folders	[SharedFolder]	Array of shared folders
assignee_id	string	none
status	string	possible values are : open
message_id	string	if the card is linked to a gmail conversation, gmail message id
notes_count	number	number of notes on the card
tags	[Tag]	Array of tags
notes	[Note]	Array of notes
updated_at	number	date when the card was last updated, can be null

Column

{ "column_id": "string", "column_name": "string", "kanban_board_id": "string", "column_index": 0, "avatar_url": "string" }

Properties

Name	Type	Description
column_id	string	column id
column_name	string	column name
kanban_board_id	string	board id
column_index	number	column index
avatar_url	string	avatar/picture of the column

Conversation

{ "conversation_id": "string", "thread_id": "string", "subject": "string", "status": "string", "users": [ { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true } ], "assignee": { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true }, "tags": [ "string" ] }

Properties

Name	Type	Description
conversation_id	string	conversation id
thread_id	string	thread id
subject	string	subject
status	string	can be either ["closed", "pending", "open"]
users	[User]	users with whom the conversation is shared
assignee	User	assignee
tags	[string]	tags list

Note

{ "user_id": "string", "note_id": 0, "thread_id": "string", "message_id": "string", "first_name": "string", "last_name": "string", "email": "string", "picture_url": "string", "body": "string", "created": 0 }

Properties

Name	Type	Description
user_id	string	user id
note_id	number	note id
thread_id	string	gmail thread id
message_id	string	gmail message id
first_name	string	first name
last_name	string	last name
email	string	email
picture_url	string	avatar url
body	string	body
created	number	created timestamp

Tag

{
  "tag_id": "string",
  "name": "string",
  "color": "string"
}

Properties

Name	Type	Description
tag_id	string	tag id
name	string	name
color	string	color

Sequence

{ "sequence_id": "string", "name": "string", "is_active": true, "created_at": 0, "updated_at": 0, "email": "string", "multiple_time_same_sequence": true, "end_after_reply": true, "one_sequence_at_a_time": true, "insert_replies": true, "working_days": true, "unsubscribe_link": true, "is_read_only": true, "shared_users": [ { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true } ], "variables": [ "string" ] }

Properties

Name	Type	Description
sequence_id	string	shared folder id
name	string	name
is_active	boolean	active or not?
created_at	number	created timestamp
updated_at	number	created timestamp
email	string	owner email
multiple_time_same_sequence	boolean	allow recipients to be enrolled in the same sequence multiple times?
end_after_reply	boolean	stop sequence for a recipient upon reply?
one_sequence_at_a_time	boolean	block recipients from being enrolled in different sequences at the same time?
insert_replies	boolean	insert the content of previous emails inside your emails?
working_days	boolean	Postpone the completion of actions to working days
unsubscribe_link	boolean	include unsubscribe link
is_read_only	boolean	in case sequence is shared by other user
shared_users	[User]	array of users
variables	[string]	array of variables

SequenceVariable

{
  "name": "string",
  "value": "string"
}

Properties

Name	Type	Description
name	string	name
value	string	value

SharedFolder

{ "shared_folder_id": "string", "name": "string", "shared_inbox": true, "created_at": 0, "owner": "string", "shared_with_users": [ { "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true } ] }

Properties

Name	Type	Description
shared_folder_id	string	shared folder id
name	string	name
shared_inbox	boolean	is it a shared inbox or a shared label?
created_at	number	created timestamp
owner	string	owner email
shared_with_users	[User]	Array of users

User

{ "user_id": "string", "user_email": "string", "user_first_name": "string", "user_last_name": "string", "picture_url": "string", "shared": true }

Properties

Name	Type	Description
user_id	string	user id
user_email	string	email
user_first_name	string	first name
user_last_name	string	last name
picture_url	string	picture url
shared	boolean	folder approved by the user?

Misc

Rate limits

To protect our servers, the Gmelius API imposes rate limits per user. We throttle requests to our API using the token bucket algorithm. For simplicity, let's say the soft-limit is 1 request per second with the same user access token. But you can sparsely send up to 100 requests at the same time.

Please note that if your application creates multiple access tokens per user, the rate limit will be shared across these tokens.

Rate limit error

When a rate limit has been exceeded, Gmelius will return a response with a status code of 429 and the error message Too Many Requests.

Details on rate limit

For applying rate limits, the Gmelius API implements the token bucket algorithm. Such an algorithm is defined by two values:

capacity: number of requests at the same time
refill-rate: rate at which new allowed requests are added per second

In fact, the Gmelius API overlays two separate token bucket algorithms with the following parameters:

Capacity	Refill-rate
100	20
1000	1

Without going into details into the algorithm, here are a few examples to help you understand these parameters:

If a caller submits requests at the rate of one per second, Gmelius processes all requests without dropping any.

If the caller sends 200 requests at once, Gmelius serves 100 of those requests and rejects the additional requests with 429 Too Many Requests error responses.

If the caller submits 100 requests at once and then evenly spreads another 100 requests through the remaining 100 seconds, Gmelius processes all 200 requests without returning 429 Too Many Requests error responses.

Special rate limit for sequences

In order to comply with Gmail limits, the endpoint for enrolling a user in a sequence has a special rate limit: an additional token-bucket with (capacity, refill rate) of (224, 1/360) if you have a @gmail.com account or (1224, 1/360) if you have a Google Workspace account is applied.

Errors

Gmelius uses the following standard error codes

Error Code	Meaning
400	Bad Request -- Your request is invalid.
401	Unauthorized -- Problem with your access token.
403	Forbidden -- You have no rights on the resource.
429	Too Many Requests -- You are requesting too many resources! Slow down!
500	Internal Server Error -- We had an unknown issue processing your request.
502	Bad Gateway -- We are having a temporary server failure. Please try again later.

Gmelius API documentation

Gmelius API Overview

How do I register?

API format

Getting started

Authentication

Authorization code flow

Get authorization code

Get access token and refresh token

Parameters

Responses

PKCE

Refreshing tokens

Refreshing access tokens

Parameters

Responses

Refreshing refresh tokens

Scopes

List of Gmelius scopes

Offline access

Scope - API endpoint correspondence

Other operations linked to authentication

Introspection

Parameters

Revocation

Parameters

User info

Responses

Quick example

Get authorization code

Get access token and refresh token

Access protected resources

Boards

List all boards

Responses

Response Schema

Create a board

Parameters

Responses

Response Schema

Get a board

Parameters

Responses

Response Schema

Update a board

Parameters

Responses

Response Schema

Delete a board

Parameters

Responses

Response Schema

Columns

List all board columns

Parameters

Responses

Response Schema

Create a column

Parameters

Responses

Response Schema

Get a board column

Parameters

Responses

Response Schema

Update a column

Parameters

Responses

Response Schema

Delete a column

Parameters

Responses

Response Schema

Cards

List all column cards

Parameters

Responses

Response Schema

Get a board card

Parameters