Shell HTTP JavaScript Ruby Python PHP Java Go

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.

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?

Sign up for Gmelius!

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.

  1. We describe the authorization code flow.
  2. We explain how to refresh an access token that has a limited lifetime of one hour.
  3. We detail scopes.
  4. We reference some API endpoints related to authentication.
  5. 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 :

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/v1/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Authorization: Basic {client-header}'

POST https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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

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/v1/token \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Authorization: Basic {client-header}'

POST https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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

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.

Other operations linked to authentication

Introspection

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

Code samples

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

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

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

fetch('https://api.gmelius.com/public/v1/token/introspection',
{
  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/v1/token/introspection',
  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/v1/token/introspection', 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/v1/token/introspection', 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/v1/token/introspection");
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/v1/token/introspection", data)
    req.Header = headers

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

POST /token/introspection

Body parameter

token: string

Parameters

Name In Type Required Description
body body object true none
» token body string true Refresh or access token

Example responses

200 Response

{
  "active": true,
  "client_id": "bfeb917a8d1d26766aba9379aecc9614-69Epx7Y2TdQzbJBw15ohR.gmelius.com",
  "sub": "718ffa1d7083ca3a7f0773d2b6b29961",
  "exp": 1605114130,
  "iat": 1605110530,
  "jti": "W-UeG_giEcxQ8X3p6GsUYHexM8vlaB50uw7TvnXCqgx",
  "scope": "openid offline_access https://api.gmelius.com/public/auth/boards/modify",
  "token_type": "Bearer"
}

Revocation

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

Code samples

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

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

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

fetch('https://api.gmelius.com/public/v1/token/revocation',
{
  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/v1/token/revocation',
  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/v1/token/revocation', 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/v1/token/revocation', 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/v1/token/revocation");
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/v1/token/revocation", data)
    req.Header = headers

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

POST /token/revocation

Body parameter

token: string

Parameters

Name In Type Required Description
body body object true none
» token body string true Refresh or access token

User info

Code samples

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

GET https://api.gmelius.com/public/v1/me 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/v1/me',
{
  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/v1/me',
  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/v1/me', 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/v1/me', 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/v1/me");
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/v1/me", data)
    req.Header = headers

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

GET /me

Example responses

200 Response

{
  "sub": "718ffa1d7083ca3a7f0773d2b6b29961",
  "email": "john@gmail.com",
  "display_name": "john smith"
}

Responses

Status Meaning Description Schema
200 OK Success None

Quick example

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

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

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/v1/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'

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/v1/auth/boards \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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://gmelius.io/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://gmelius.io/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/v1/auth/board/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{id}", data)
    req.Header = headers

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

GET /auth/board/{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://gmelius.io/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://gmelius.io/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/v1/auth/board/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{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/v1/auth/board/{id}", data)
    req.Header = headers

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

PUT /auth/board/{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://gmelius.io/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://gmelius.io/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/v1/auth/board \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

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

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

fetch('https://api.gmelius.com/public/v1/auth/board',
{
  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/v1/auth/board',
  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/v1/auth/board', 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/v1/auth/board', 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/v1/auth/board");
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/v1/auth/board", data)
    req.Header = headers

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

POST /auth/board

Body parameter

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

Parameters

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

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://gmelius.io/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://gmelius.io/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/v1/auth/board?boardId=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v1/auth/board?boardId=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/v1/auth/board?boardId=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/v1/auth/board',
  params: {
  'boardId' => '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/v1/auth/board', params={
  'boardId': '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/v1/auth/board', 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/v1/auth/board?boardId=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/v1/auth/board", data)
    req.Header = headers

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

DELETE /auth/board

Parameters

Name In Type Required Description
boardId query 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/v1/auth/boards/{id}/columns \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/{id}/columns \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/columns/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/columns/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PATCH https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/columns/{id}?archiveCards=true \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/columns/{id}/cards \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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": "KxzuidoiuxmWCM",
      "card_index": 128,
      "priority": "",
      "subject": "short description, subject",
      "snippet": "longer description, memo",
      "sender": "john.doe@domain.com",
      "sender_name": "John Doe",
      "calendar_id": "google calendar id",
      "calendar_event_id": "google calendar event id",
      "sent_date": 1602507213,
      "thread_id": "gmail threadId for current user",
      "column_id": "KxycdiekdumwWM",
      "due_date": 1602508000,
      "total_tasks": 12,
      "completed_tasks": 6,
      "vertical_row_index": 0,
      "conversation_id": "ZcfwixmdjMWmXM",
      "shared_folders": [
        {
          "shared_folder_id": "UizuxiwmcWxmW",
          "name": "My shared folder"
        }
      ],
      "assignee_id": "QwzurtetuxnbxuW",
      "status": "open",
      "message_id": "gmail current thread messageId for current user",
      "notes_count": 1,
      "tags": [
        {
          "tag_id": "TzueeiwwxnjuwWM",
          "name": "Tag 1",
          "color": "#223344"
        }
      ],
      "notes": [
        {
          "user_id": "4019106a8bc9516fd19ee54b77bbcd",
          "note_id": "ZcfwixmdjMWmXM",
          "first_name": "John",
          "last_name": "Doe",
          "email": "john.doe@gmail.com",
          "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://gmelius.io/assets/logo/color_100.png",
          "body": "Note test 1",
          "created": 1602507213
        }
      ],
      "updated_at": 1602507300
    }
  ]
}

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/v1/auth/boards/cards/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/auth/boards/cards/{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/v1/auth/boards/cards/{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/v1/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('GET','https://api.gmelius.com/public/v1/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/v1/auth/boards/cards/{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/v1/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

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "card_id": "KxzuidoiuxmWCM",
    "card_index": 128,
    "priority": "",
    "subject": "short description, subject",
    "snippet": "longer description, memo",
    "sender": "john.doe@domain.com",
    "sender_name": "John Doe",
    "calendar_id": "google calendar id",
    "calendar_event_id": "google calendar event id",
    "sent_date": 1602507213,
    "thread_id": "gmail threadId for current user",
    "column_id": "KxycdiekdumwWM",
    "due_date": 1602508000,
    "total_tasks": 12,
    "completed_tasks": 6,
    "vertical_row_index": 0,
    "conversation_id": "ZcfwixmdjMWmXM",
    "shared_folders": [
      {
        "shared_folder_id": "UizuxiwmcWxmW",
        "name": "My shared folder"
      }
    ],
    "assignee_id": "QwzurtetuxnbxuW",
    "status": "open",
    "message_id": "gmail current thread messageId for current user",
    "notes_count": 1,
    "tags": [
      {
        "tag_id": "TzueeiwwxnjuwWM",
        "name": "Tag 1",
        "color": "#223344"
      }
    ],
    "notes": [
      {
        "user_id": "4019106a8bc9516fd19ee54b77bbcd",
        "note_id": "ZcfwixmdjMWmXM",
        "first_name": "John",
        "last_name": "Doe",
        "email": "john.doe@gmail.com",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://gmelius.io/assets/logo/color_100.png",
        "body": "Note test 1",
        "created": 1602507213
      }
    ],
    "updated_at": 1602507300
  }
}

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/v1/auth/boards/cards/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

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

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

fetch('https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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",
  "sender_name": "string",
  "sender_mail": "string",
  "vertical_row_index": 0,
  "due_date": 0,
  "priority": "string",
  "status": "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)
» sender_name body string false name corresponding to the email
» sender_mail body string false sender email
» vertical_row_index body number false index of the vertical row where to insert the card (0 = normal, 1 = pending column sub-category)
» due_date body number false due date of the card
» priority body string false possible values : 'high', 'medium', 'low', null
» status body string false possible values : 'open', 'pending', 'closed'

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "card_id": "KxzuidoiuxmWCM",
    "card_index": 128,
    "priority": "",
    "subject": "short description, subject",
    "snippet": "longer description, memo",
    "sender": "john.doe@domain.com",
    "sender_name": "John Doe",
    "calendar_id": "google calendar id",
    "calendar_event_id": "google calendar event id",
    "sent_date": 1602507213,
    "thread_id": "gmail threadId for current user",
    "column_id": "KxycdiekdumwWM",
    "due_date": 1602508000,
    "total_tasks": 12,
    "completed_tasks": 6,
    "vertical_row_index": 0,
    "conversation_id": "ZcfwixmdjMWmXM",
    "shared_folders": [
      {
        "shared_folder_id": "UizuxiwmcWxmW",
        "name": "My shared folder"
      }
    ],
    "assignee_id": "QwzurtetuxnbxuW",
    "status": "open",
    "message_id": "gmail current thread messageId for current user",
    "notes_count": 1,
    "tags": [
      {
        "tag_id": "TzueeiwwxnjuwWM",
        "name": "Tag 1",
        "color": "#223344"
      }
    ],
    "notes": [
      {
        "user_id": "4019106a8bc9516fd19ee54b77bbcd",
        "note_id": "ZcfwixmdjMWmXM",
        "first_name": "John",
        "last_name": "Doe",
        "email": "john.doe@gmail.com",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://gmelius.io/assets/logo/color_100.png",
        "body": "Note test 1",
        "created": 1602507213
      }
    ],
    "updated_at": 1602507300
  }
}

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/v1/auth/boards/cards/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/cards \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v1/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",
  "sender_email": "string",
  "sender_name": "string",
  "vertical_row_index": 0,
  "due_date": 0,
  "insert_at_end": true,
  "create_conversation": true,
  "conversation_details": 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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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",
  "sender_email": "string",
  "sender_name": "string",
  "vertical_row_index": 0,
  "due_date": 0,
  "insert_at_end": true,
  "create_conversation": true,
  "conversation_details": 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
» sender_email body string true sender email
» sender_name body string false name corresponding to the email
» vertical_row_index body number false index of the vertical row where to insert the card (0 = normal, 1 = pending column sub-category)
» 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
» conversation_details body boolean false wait until we have the details of the created conversation before returning
» 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": 200,
    "code": "Ok"
  },
  "data": {
    "card_id": "KxzuidoiuxmWCM",
    "card_index": 128,
    "priority": "",
    "subject": "short description, subject",
    "snippet": "longer description, memo",
    "sender": "john.doe@domain.com",
    "sender_name": "John Doe",
    "calendar_id": "google calendar id",
    "calendar_event_id": "google calendar event id",
    "sent_date": 1602507213,
    "thread_id": "gmail threadId for current user",
    "column_id": "KxycdiekdumwWM",
    "due_date": 1602508000,
    "total_tasks": 12,
    "completed_tasks": 6,
    "vertical_row_index": 0,
    "conversation_id": "ZcfwixmdjMWmXM",
    "shared_folders": [
      {
        "shared_folder_id": "UizuxiwmcWxmW",
        "name": "My shared folder"
      }
    ],
    "assignee_id": "QwzurtetuxnbxuW",
    "status": "open",
    "message_id": "gmail current thread messageId for current user",
    "notes_count": 1,
    "tags": [
      {
        "tag_id": "TzueeiwwxnjuwWM",
        "name": "Tag 1",
        "color": "#223344"
      }
    ],
    "notes": [
      {
        "user_id": "4019106a8bc9516fd19ee54b77bbcd",
        "note_id": "ZcfwixmdjMWmXM",
        "first_name": "John",
        "last_name": "Doe",
        "email": "john.doe@gmail.com",
        "picture_url": "https://www.gravatar.com/avatar/3089106a8bc9516fd19ee54b77bace37?s=128&d=https://gmelius.io/assets/logo/color_100.png",
        "body": "Note test 1",
        "created": 1602507213
      }
    ],
    "updated_at": 1602507300
  }
}

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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/boards/cards/{id}/tags/{tag_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/sharedfolders \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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

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/v1/auth/sharedfolders/{id}/conversations \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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",
        "created_at": 1605783908,
        "thread_id": "175e02daf08dc789",
        "status": "Open",
        "assignee_email": "john.doe2@gmail.com"
      }
    ],
    "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/v1/auth/conversations/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/auth/conversations/{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/v1/auth/conversations/{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/v1/auth/conversations/{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/v1/auth/conversations/{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/v1/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/v1/auth/conversations/{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/v1/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

Example responses

200 Response

{
  "meta": {
    "status": 200,
    "code": "Ok"
  },
  "data": {
    "users": [
      {
        "user_email": "bernard@gmail.com",
        "user_first_name": "bernard",
        "user_last_name": "brown",
        "user_display_name": "bernard brown"
      },
      {
        "user_email": "alan@gmail.com",
        "user_first_name": "alan",
        "user_last_name": "amsted",
        "user_display_name": "alan amsted"
      }
    ],
    "status": "Open",
    "assignee": {
      "user_email": "bernard@gmail.com",
      "user_first_name": "bernard",
      "user_last_name": "brown",
      "user_display_name": "bernard brown"
    },
    "thread_id": "1723324a5d0c9729",
    "subject": "mysubject"
  }
}

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/v1/auth/conversations/{id}/notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/conversations/{id}/reply \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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

Assign a conversation

Code samples

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

PUT https://api.gmelius.com/public/v1/auth/conversations/{id}/assign 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/v1/auth/conversations/{id}/assign',
{
  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/v1/auth/conversations/{id}/assign',
  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/v1/auth/conversations/{id}/assign', 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/v1/auth/conversations/{id}/assign', 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/v1/auth/conversations/{id}/assign");
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/v1/auth/conversations/{id}/assign", data)
    req.Header = headers

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

PUT /auth/conversations/{id}/assign

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/v1/auth/conversations/{id}/status \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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

Metadata

Access to metadata

Create a note

Code samples

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

POST https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/notes/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/notes/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/tags/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PATCH https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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.

  1. Get a token by authorizing with OAuth 2.0
  2. POST https://api.gmelius.com/public/v1/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/v1/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 :

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_tag when a tag is applied on a card
remove_card_tag when a tag is removed from a card
update_card_tag when a tag is updated on a card (its name can be changed)
delete_card_tag when a tag is completely deleted from a card and Gmelius subscription
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
assign_conversation when a conversation is assigned
change_status_conversation when a conversation status is updated

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/v1/auth/webhooks \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/auth/webhooks \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.gmelius.com/public/v1/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",
  "validUntil": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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",
  "validUntil": 0
}

Parameters

Name In Type Required Description
body body object true none
» type body string true can be 'board' or 'shared_folder'
» model_id body string true the model to listen to, either boardId or sharedLabelId
» description body string false description
» callback_url body string true callback url to trigger
» validUntil 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

Delete a webhook

Code samples

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

DELETE https://api.gmelius.com/public/v1/auth/webhooks?webhookId=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/v1/auth/webhooks?webhookId=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/v1/auth/webhooks',
  params: {
  'webhookId' => '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/v1/auth/webhooks', params={
  'webhookId': '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/v1/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/v1/auth/webhooks?webhookId=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/v1/auth/webhooks", data)
    req.Header = headers

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

DELETE /auth/webhooks

Parameters

Name In Type Required Description
webhookId query 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

List all events of a webhook

Code samples

# You can also use wget
curl -X GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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 unix timestamp (seconds)
limit query number true unix timestamp (seconds)

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/v1/auth/webhooks/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.gmelius.com/public/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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/v1/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

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",
    "email": "string",
    "first_name": "string",
    "last_name": "string",
    "picture_url": "string",
    "approval": true
  },
  "users": [
    {
      "user_id": "string",
      "email": "string",
      "first_name": "string",
      "last_name": "string",
      "picture_url": "string",
      "approval": 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",
          "email": "string",
          "first_name": "string",
          "last_name": "string",
          "picture_url": "string",
          "approval": 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

{
  "thread_id": "string",
  "subject": "string",
  "status": "string",
  "users": [
    {
      "user_id": "string",
      "email": "string",
      "first_name": "string",
      "last_name": "string",
      "picture_url": "string",
      "approval": true
    }
  ],
  "assignee": {
    "user_id": "string",
    "email": "string",
    "first_name": "string",
    "last_name": "string",
    "picture_url": "string",
    "approval": true
  }
}

Properties

Name Type Description
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

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

SharedFolder

{
  "shared_folder_id": "string",
  "name": "string",
  "shared_inbox": true,
  "created_at": 0,
  "owner": "string",
  "shared_with_users": [
    {
      "user_id": "string",
      "email": "string",
      "first_name": "string",
      "last_name": "string",
      "picture_url": "string",
      "approval": 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",
  "email": "string",
  "first_name": "string",
  "last_name": "string",
  "picture_url": "string",
  "approval": true
}

Properties

Name Type Description
user_id string user id
email string email
first_name string first name
last_name string last name
picture_url string picture url
approval boolean has the user approved the shared folder

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:

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.

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.