NAV Navbar
Shell HTTP JavaScript Node.JS Ruby Python Java Go

Fluida API v1.0.0

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

Fluida API integration guide

Base URLs:

Authentication

Scope Scope Description
write:team Team write
write:stamping_device Stamping device write
write:stamping_area Stamping area write
write:stamping Stamping write
write:schedule Schedule write
write:justification_type Justification type write
write:justification Justification write
write:holiday Holiday write
write:export Export write
write:contract Contract write
write:company_communication_message Company communication message write
write:company_communication Company communication write
write:company Company write
read:team Team read
read:stamping_device Stamping device read
read:stamping_area Stamping area read
read:stamping Stamping read
read:schedule Schedule read
read:justification_type Justification type read
read:justification Justification read
read:holiday Holiday read
read:export Export read
read:contract Contract read
read:company_communication_message Company communication message read
read:company_communication Company communication read
read:company Company read
read:calendar Calendar read

Company

Creates a team for a given company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/teams \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/teams HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "team_leader_ids": [
    "7b3924af-4379-40f7-b209-cc7142a8aeb2",
    "8dee3012-94be-4f22-b5cc-8e2b75d906cc"
  ],
  "subsidiary_id": "8aa0d966-cf2a-44a2-a391-ab1e66b07504",
  "name": "Thompson-Emard",
  "company_id": "a4a1a072-cb3f-476b-95f4-c96901028775",
  "code": "47395 Gus Unions"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/teams',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/teams', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/teams", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/teams

Creates a team for a given company...

Body parameter

{
  "team_leader_ids": [
    "7b3924af-4379-40f7-b209-cc7142a8aeb2",
    "8dee3012-94be-4f22-b5cc-8e2b75d906cc"
  ],
  "subsidiary_id": "8aa0d966-cf2a-44a2-a391-ab1e66b07504",
  "name": "Thompson-Emard",
  "company_id": "a4a1a072-cb3f-476b-95f4-c96901028775",
  "code": "47395 Gus Unions"
}

Parameters

Name In Type Required Description
company_id path string true company id
body body Team false team attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of teams for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/teams \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/teams HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams',
{
  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.fluida.io/api/v1/companies/{company_id}/teams',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/teams', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams");
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.fluida.io/api/v1/companies/{company_id}/teams", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/teams

Renders a list of teams for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "team_leader_ids": [
      "7b3924af-4379-40f7-b209-cc7142a8aeb2",
      "8dee3012-94be-4f22-b5cc-8e2b75d906cc"
    ],
    "subsidiary_id": "8aa0d966-cf2a-44a2-a391-ab1e66b07504",
    "name": "Thompson-Emard",
    "company_id": "a4a1a072-cb3f-476b-95f4-c96901028775",
    "code": "47395 Gus Unions"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Teams

Upgrades a contract to team leader

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "team_id": "string",
  "contract_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract

Upgrades a contract to team leader...

Body parameter

{
  "team_id": "string",
  "contract_id": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
team_id path string true team id
body body ContractTeamParams false team attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Creates a company communication message

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/:company_id/communications \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/:company_id/communications HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "subject": "string",
  "status": "string",
  "sender_id": "string",
  "send_at": "string",
  "recurrent_until": "string",
  "recurrent": "string",
  "message": "string",
  "destination_team_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "company_id": "string",
  "change_log": [
    {}
  ],
  "attachments": [
    {
      "name": "string",
      "mime": "string",
      "id": "string"
    }
  ],
  "action_required": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/:company_id/communications',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/:company_id/communications', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/:company_id/communications", data)
    req.Header = headers

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

POST /api/v1/companies/:company_id/communications

Creates a company communication message...

Body parameter

{
  "subject": "string",
  "status": "string",
  "sender_id": "string",
  "send_at": "string",
  "recurrent_until": "string",
  "recurrent": "string",
  "message": "string",
  "destination_team_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "company_id": "string",
  "change_log": [
    {}
  ],
  "attachments": [
    {
      "name": "string",
      "mime": "string",
      "id": "string"
    }
  ],
  "action_required": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
body body Communication false company communication

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Shows company communications

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/:company_id/communications HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications", data)
    req.Header = headers

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

GET /api/v1/companies/:company_id/communications

Shows company communications...

Parameters

Name In Type Required Description
company_id path string true company id
year query integer false filter communications by year
status query string false filter communications by status

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success Communications
401 Unauthorized Unauthorized Unauthorized

Downgrades a contract from team leader

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "team_id": "string",
  "contract_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract

Downgrades a contract from team leader...

Body parameter

{
  "team_id": "string",
  "contract_id": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
team_id path string true team id
body body ContractTeamParams false team attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Updates a teams for a given company

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "team_leader_ids": [
    "7b3924af-4379-40f7-b209-cc7142a8aeb2",
    "8dee3012-94be-4f22-b5cc-8e2b75d906cc"
  ],
  "subsidiary_id": "8aa0d966-cf2a-44a2-a391-ab1e66b07504",
  "name": "Thompson-Emard",
  "company_id": "a4a1a072-cb3f-476b-95f4-c96901028775",
  "code": "47395 Gus Unions"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/teams/{team_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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/teams/{team_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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}", data)
    req.Header = headers

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

PUT /api/v1/companies/:company_id/teams/{team_id}

Updates a teams for a given company...

Body parameter

{
  "team_leader_ids": [
    "7b3924af-4379-40f7-b209-cc7142a8aeb2",
    "8dee3012-94be-4f22-b5cc-8e2b75d906cc"
  ],
  "subsidiary_id": "8aa0d966-cf2a-44a2-a391-ab1e66b07504",
  "name": "Thompson-Emard",
  "company_id": "a4a1a072-cb3f-476b-95f4-c96901028775",
  "code": "47395 Gus Unions"
}

Parameters

Name In Type Required Description
company_id path string true company id
team_id path string true team id
body body Team false team attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of authorized scopes for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes',
{
  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.fluida.io/api/v1/companies/{company_id}/authorized/scopes',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes");
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.fluida.io/api/v1/companies/{company_id}/authorized/scopes", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/authorized/scopes

Renders a list of authorized scopes for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "name": "Justification",
    "mode": [
      "read",
      "write"
    ],
    "api": "justification"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Scopes

Renders a list of company holidays

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/holidays \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/holidays HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/holidays',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/holidays',
{
  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.fluida.io/api/v1/companies/{company_id}/holidays',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/holidays', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/holidays");
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.fluida.io/api/v1/companies/{company_id}/holidays", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/holidays

Renders a list of company holidays...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "recurrent_until": "string",
    "recurrent": "string",
    "name": "string",
    "is_worker_holiday": true,
    "day": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Holidays

Updates a company communication

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/communications/:id \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/:company_id/communications/:id HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "subject": "string",
  "status": "string",
  "sender_id": "string",
  "send_at": "string",
  "recurrent_until": "string",
  "recurrent": "string",
  "message": "string",
  "destination_team_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "company_id": "string",
  "change_log": [
    {}
  ],
  "attachments": [
    {
      "name": "string",
      "mime": "string",
      "id": "string"
    }
  ],
  "action_required": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/: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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/communications/:id', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/: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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/communications/:id", data)
    req.Header = headers

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

PUT /api/v1/companies/:company_id/communications/:id

Updates a company communication...

Body parameter

{
  "subject": "string",
  "status": "string",
  "sender_id": "string",
  "send_at": "string",
  "recurrent_until": "string",
  "recurrent": "string",
  "message": "string",
  "destination_team_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "company_id": "string",
  "change_log": [
    {}
  ],
  "attachments": [
    {
      "name": "string",
      "mime": "string",
      "id": "string"
    }
  ],
  "action_required": "string"
}

Parameters

Name In Type Required Description
id path string true communication id
company_id path string true company id
body body Communication false communication

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Shows a communication

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/:id \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/:company_id/communications/:id HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/:id', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/: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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/:id", data)
    req.Header = headers

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

GET /api/v1/companies/:company_id/communications/:id

Shows a communication...

Parameters

Name In Type Required Description
id path string true communication id
company_id path string true company id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success Communication
401 Unauthorized Unauthorized Unauthorized

Shows communication reports

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report", data)
    req.Header = headers

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

GET /api/v1/companies/:company_id/communications/:communication_id/report

Shows communication reports...

Parameters

Name In Type Required Description
communication_id path string true communication id
company_id path string true company id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success CommunicationReports
401 Unauthorized Unauthorized Unauthorized

Renders a list of all holidays

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/all_holidays \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/all_holidays HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/all_holidays',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/all_holidays',
{
  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.fluida.io/api/v1/companies/{company_id}/all_holidays',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/all_holidays', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/all_holidays");
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.fluida.io/api/v1/companies/{company_id}/all_holidays", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/all_holidays

Renders a list of all holidays...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "recurrent_until": "string",
    "recurrent": "string",
    "name": "string",
    "is_worker_holiday": true,
    "day": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Holidays

Renders a list of subsidiary holidays

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays',
{
  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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays");
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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays

Renders a list of subsidiary holidays...

Parameters

Name In Type Required Description
company_id path string true company id
subsidiary_id path string true subsidiary id

Example responses

200 Response

[
  {
    "recurrent_until": "string",
    "recurrent": "string",
    "name": "string",
    "is_worker_holiday": true,
    "day": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Holidays

Lists communication messages

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id',
  method: 'get',
  data: '?send_at=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id',
  params: {
  'send_at' => 'string'
}, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id', params={
  'send_at': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id", data)
    req.Header = headers

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

GET /api/v1/companies/:company_id/communications/messages/by_communication/:communication_id

Lists communication messages

Parameters

Name In Type Required Description
company_id path string true company id
communication_id path string true communication id
send_at query string true send_at
page query integer false page number
page_size query integer false number of results per page
opened query boolean false filter opened messages
actions query boolean false filter messages with action_done

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success CommunicationMessages
401 Unauthorized Unauthorized Unauthorized

Disables a company

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}',
{
  method: 'PUT',

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

require 'rest-client'
require 'json'

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

result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_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{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}

Disables a company...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a company for a given id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_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.fluida.io/api/v1/companies/{company_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_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.fluida.io/api/v1/companies/{company_id}", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}

Renders a company for a given id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

{
  "zip": "92328",
  "vat": "123456789-0",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "timezone": "Europe/Rome",
  "subscription_status": "active",
  "subscription_plan": "started",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscribed_features": [
    "export"
  ],
  "province": "TO",
  "preferences": {
    "stamping_enabled": "true"
  },
  "plan_quantity": 10,
  "phone": "07881 836703",
  "pec": "foo.bar@pec.it",
  "number_of_employees": 20,
  "name": "Marks-Kemmer",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "fiscal_code": "ABCDEF12A01H501-1",
  "country": "Lithuania",
  "codice_destinatario": "000000",
  "city": "Ritchieberg",
  "billing_email": "billing-1@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "admin_user_email": "company-admin-0@example.com",
  "address": "14138 Cummerata Brooks"
}

Responses

Status Meaning Description Schema
200 OK Success Company

Adds a contract to a list of teams

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "team_ids": [
    "string"
  ],
  "contract_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/contracts/{id}/add_to_teams

Adds a contract to a list of teams...

Body parameter

{
  "team_ids": [
    "string"
  ],
  "contract_id": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
id path string true team id
body body ContractTeamsParams false team attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Lists communication messages by contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id", data)
    req.Header = headers

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

GET /api/v1/companies/:company_id/communications/messages/by_contract/:contract_id

Lists communication messages by contract

Parameters

Name In Type Required Description
company_id path string true company id
contract_id path string true contract id
page query integer false page number
page_size query integer false number of results per page
opened query boolean false filter opened messages
year query integer false filter messages by year
actions query boolean false filter messages with action_done

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success CommunicationMessages
401 Unauthorized Unauthorized Unauthorized

Adds a weekly closing day to subsidiary

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "weekday": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days

Adds a weekly closing day to subsidiary...

Body parameter

{
  "weekday": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
subsidiary_id path string true subsidiary id
body body Weekday true weekday

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of subsidiary weekly closing days for a given subsidiary id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
{
  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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days");
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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days

Renders a list of subsidiary weekly closing days for a given subsidiary id...

Parameters

Name In Type Required Description
company_id path string true company id
subsidiary_id path string true subsidiary id

Example responses

200 Response

{
  "weekday": "string",
  "subsidiary_id": "string",
  "company_id": "string"
}

Responses

Status Meaning Description Schema
200 OK Success SubsidiaryWeeklyClosingDays

Gets a company communication attachment

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/: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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id", data)
    req.Header = headers

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

GET /companies/:company_id/communications/attachments/by_contract/:contract_id/:id

Gets a company communication attachment...

Parameters

Name In Type Required Description
company_id path string true company id
contract_id path string true contract id
id path string true attachment id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success Avatar

Creates a company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "zip": "92328",
  "vat": "123456789-0",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "timezone": "Europe/Rome",
  "subscription_status": "active",
  "subscription_plan": "started",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscribed_features": [
    "export"
  ],
  "province": "TO",
  "preferences": {
    "stamping_enabled": "true"
  },
  "plan_quantity": 10,
  "phone": "07881 836703",
  "pec": "foo.bar@pec.it",
  "number_of_employees": 20,
  "name": "Marks-Kemmer",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "fiscal_code": "ABCDEF12A01H501-1",
  "country": "Lithuania",
  "codice_destinatario": "000000",
  "city": "Ritchieberg",
  "billing_email": "billing-1@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "admin_user_email": "company-admin-0@example.com",
  "address": "14138 Cummerata Brooks"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies", data)
    req.Header = headers

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

POST /api/v1/companies

Creates a company...

Body parameter

{
  "zip": "92328",
  "vat": "123456789-0",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "timezone": "Europe/Rome",
  "subscription_status": "active",
  "subscription_plan": "started",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscribed_features": [
    "export"
  ],
  "province": "TO",
  "preferences": {
    "stamping_enabled": "true"
  },
  "plan_quantity": 10,
  "phone": "07881 836703",
  "pec": "foo.bar@pec.it",
  "number_of_employees": 20,
  "name": "Marks-Kemmer",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "fiscal_code": "ABCDEF12A01H501-1",
  "country": "Lithuania",
  "codice_destinatario": "000000",
  "city": "Ritchieberg",
  "billing_email": "billing-1@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "admin_user_email": "company-admin-0@example.com",
  "address": "14138 Cummerata Brooks"
}

Parameters

Name In Type Required Description
body body Company false company attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Removes a contract from a team

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}

Removes a contract from a team...

Parameters

Name In Type Required Description
company_id path string true company id
team_id path string true team id
contract_id path string true contract id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Removes a weekly closing day from company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/weekly_closing_days/{id}

Removes a weekly closing day from company...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true weekday id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Adds a weekly closing day to company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "weekday": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/weekly_closing_days

Adds a weekly closing day to company...

Body parameter

{
  "weekday": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
body body Weekday true weekday

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of weekly closing days for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
{
  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.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days");
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.fluida.io/api/v1/companies/{company_id}/weekly_closing_days", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/weekly_closing_days

Renders a list of weekly closing days for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

{
  "weekday": "string",
  "company_id": "string"
}

Responses

Status Meaning Description Schema
200 OK Success CompanyWeeklyClosingDays

Puts a company communication attachment

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "avatar": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments", data)
    req.Header = headers

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

POST /api/v1/companies/:company_id/communications/:communication_id/attachments

Puts a company communication attachment...

Body parameter

{
  "avatar": {}
}

Parameters

Name In Type Required Description
company_id path string true company id
communication_id path string true communication id
body body Avatar true document attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Creates a subsidiary for a given company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "zip": "61290",
  "timezone": "Europe/Rome",
  "ref_code": "12390193",
  "province": "South",
  "name": "Thompson-Emard",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "country": "Spain",
  "company_id": "4f079875-000a-4a79-afe4-8ae84306e83b",
  "city": "Port Holdenville",
  "address": "47395 Gus Unions"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/subsidiaries

Creates a subsidiary for a given company...

Body parameter

{
  "zip": "61290",
  "timezone": "Europe/Rome",
  "ref_code": "12390193",
  "province": "South",
  "name": "Thompson-Emard",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "country": "Spain",
  "company_id": "4f079875-000a-4a79-afe4-8ae84306e83b",
  "city": "Port Holdenville",
  "address": "47395 Gus Unions"
}

Parameters

Name In Type Required Description
company_id path string true company id
body body Subsidiary false subsidiary attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of subsidiaries for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
{
  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.fluida.io/api/v1/companies/{company_id}/subsidiaries',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries");
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.fluida.io/api/v1/companies/{company_id}/subsidiaries", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/subsidiaries

Renders a list of subsidiaries for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "zip": "61290",
    "timezone": "Europe/Rome",
    "ref_code": "12390193",
    "province": "South",
    "name": "Thompson-Emard",
    "location_info": {
      "long": "0",
      "lat": "43"
    },
    "country": "Spain",
    "company_id": "4f079875-000a-4a79-afe4-8ae84306e83b",
    "city": "Port Holdenville",
    "address": "47395 Gus Unions"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Subsidiaries

Creates a company api key

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/api_keys \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/api_keys HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "type": "full",
  "scopes": [],
  "name": "Full access api"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/api_keys', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/api_keys

Creates a company api key...

Body parameter

{
  "type": "full",
  "scopes": [],
  "name": "Full access api"
}

Parameters

Name In Type Required Description
company_id path string true company id
body body ApiKey false api key attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

List company api keys

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/api_keys', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/api_keys

List company api keys...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success ApiKeys
401 Unauthorized Unauthorized Unauthorized

Renders a timesheet company summary

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary',
{
  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.fluida.io/api/v1/companies/{company_id}/timesheet_summary',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary");
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.fluida.io/api/v1/companies/{company_id}/timesheet_summary", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/timesheet_summary

Renders a timesheet company summary

Parameters

Name In Type Required Description
company_id path string true company id
contract_id query string false Contract id
team_ids query array[string] false Team Ids
subsidiary_ids query array[string] false Subsidiary Ids
start_date query string false Start date
end_date query string false End date

Example responses

200 Response

[]

Responses

Status Meaning Description Schema
200 OK Success Summary

Removes a weekly closing day from subsidiary

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}

Removes a weekly closing day from subsidiary...

Parameters

Name In Type Required Description
company_id path string true company id
subsidiary_id path string true subsidiary id
id path string true weekday id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Updates a subsidiary for a given company

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "zip": "61290",
  "timezone": "Europe/Rome",
  "ref_code": "12390193",
  "province": "South",
  "name": "Thompson-Emard",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "country": "Spain",
  "company_id": "4f079875-000a-4a79-afe4-8ae84306e83b",
  "city": "Port Holdenville",
  "address": "47395 Gus Unions"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}", data)
    req.Header = headers

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

PUT /api/v1/companies/:company_id/subsidiaries/{id}

Updates a subsidiary for a given company...

Body parameter

{
  "zip": "61290",
  "timezone": "Europe/Rome",
  "ref_code": "12390193",
  "province": "South",
  "name": "Thompson-Emard",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "country": "Spain",
  "company_id": "4f079875-000a-4a79-afe4-8ae84306e83b",
  "city": "Port Holdenville",
  "address": "47395 Gus Unions"
}

Parameters

Name In Type Required Description
company_id path string true company id
id path string true subsidiary id
body body Subsidiary false subsidiary attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a subsidiary for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/subsidiaries/{id}

Renders a subsidiary for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true subsidiary id

Example responses

200 Response

{
  "zip": "61290",
  "timezone": "Europe/Rome",
  "ref_code": "12390193",
  "province": "South",
  "name": "Thompson-Emard",
  "location_info": {
    "long": "0",
    "lat": "43"
  },
  "country": "Spain",
  "company_id": "4f079875-000a-4a79-afe4-8ae84306e83b",
  "city": "Port Holdenville",
  "address": "47395 Gus Unions"
}

Responses

Status Meaning Description Schema
200 OK Success Subsidiary

Deletes a subsidiary for a given company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/subsidiaries/{id}

Deletes a subsidiary for a given company...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true subsidiary id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of holidays by dates

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates',
{
  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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates");
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.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates

Renders a list of holidays between two dates

Parameters

Name In Type Required Description
company_id path string true company id
subsidiary_id path string true subsidiary id
start_date query string false Start date
end_date query string false End date

Example responses

200 Response

[
  {
    "recurrent_until": "string",
    "recurrent": "string",
    "name": "string",
    "is_worker_holiday": true,
    "day": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Holidays

Renders a team for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{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.fluida.io/api/v1/companies/{company_id}/teams/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{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.fluida.io/api/v1/companies/{company_id}/teams/{id}", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/teams/{id}

Renders a team for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true team id

Example responses

200 Response

{
  "team_leader_ids": [
    "7b3924af-4379-40f7-b209-cc7142a8aeb2",
    "8dee3012-94be-4f22-b5cc-8e2b75d906cc"
  ],
  "subsidiary_id": "8aa0d966-cf2a-44a2-a391-ab1e66b07504",
  "name": "Thompson-Emard",
  "company_id": "a4a1a072-cb3f-476b-95f4-c96901028775",
  "code": "47395 Gus Unions"
}

Responses

Status Meaning Description Schema
200 OK Success Team

Deletes a team for a given company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/teams/{id}

Deletes a team for a given company...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true team id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Adds a contract to a team

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "team_id": "string",
  "contract_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/teams/{team_id}/add_contract

Adds a contract to a team...

Body parameter

{
  "team_id": "string",
  "contract_id": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
team_id path string true team id
body body ContractTeamParams false team attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Creates a missing approver notification

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver',
{
  method: 'POST',

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

require 'rest-client'
require 'json'

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

result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/contracts/{id}/missing_approver

Creates a missing approver notification...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true contract id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Updates a communication message

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "opened": true,
  "action_done_at": "string",
  "action_done": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/: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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/: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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id", data)
    req.Header = headers

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

PUT /api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id

Updates a communication message...

Body parameter

{
  "opened": true,
  "action_done_at": "string",
  "action_done": "string"
}

Parameters

Name In Type Required Description
id path string true communication_message id
company_id path string true company id
contract_id path string true company id
body body CommunicationMessageAction false communication message

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Shows a communication message

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/: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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id", data)
    req.Header = headers

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

GET /api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id

Shows a communication message...

Parameters

Name In Type Required Description
id path string true communication message id
contract_id path string true contract id
company_id path string true company id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success CommunicationMessage
401 Unauthorized Unauthorized Unauthorized

Updates a company api key

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/api_keys/{id}

Updates a company api key...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true api key id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Gets a company api key

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/api_keys/{id}

Gets a company api key...

Parameters

Name In Type Required Description
company_id path string true company id
api_key_id path string true api key id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success ApiKey
401 Unauthorized Unauthorized Unauthorized

Stamping

Updates chosen stamping contract areas

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/contracts/{id}/areas \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/contracts/{id}/areas HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/contracts/{id}/areas',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "areas": [
    {}
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/contracts/{id}/areas',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/contracts/{id}/areas',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/contracts/{id}/areas', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/contracts/{id}/areas");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/stampings/contracts/{id}/areas", data)
    req.Header = headers

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

PUT /api/v1/stampings/contracts/{id}/areas

Updates chosen stamping contract areas...

Body parameter

{
  "areas": [
    {}
  ]
}

Parameters

Name In Type Required Description
id path string true contract id
body body ContractStampingAreas false contract areas attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a company stamping device

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{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.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{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.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/devices/by_id/{id}

Renders a company stamping device...

Parameters

Name In Type Required Description
company_id path string true company id
id path string true device id

Example responses

200 Response

{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}

Responses

Status Meaning Description Schema
200 OK Success StampingDevice

Create stamping area

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/areas \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/areas HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/areas',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/areas',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/stampings/areas',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/areas', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/areas");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/stampings/areas", data)
    req.Header = headers

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

POST /api/v1/stampings/areas

Create stamping area...

Body parameter

{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}

Parameters

Name In Type Required Description
body body StampingArea false stamping area attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Updates chosen stamping area contracts

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/areas/{id}/contracts \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/areas/{id}/contracts HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/areas/{id}/contracts',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "contract_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/areas/{id}/contracts',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/areas/{id}/contracts',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/areas/{id}/contracts', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/areas/{id}/contracts");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/stampings/areas/{id}/contracts", data)
    req.Header = headers

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

PUT /api/v1/stampings/areas/{id}/contracts

Updates chosen stamping area contracts...

Body parameter

{
  "contract_ids": [
    "string"
  ]
}

Parameters

Name In Type Required Description
id path string true stamping area id
body body StampingAreaContracts false stamping area attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders clock record by id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/get/{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.fluida.io/api/v1/stampings/{contract_id}/get/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/{contract_id}/get/{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.fluida.io/api/v1/stampings/{contract_id}/get/{id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{contract_id}/get/{id}

Renders clock record by id.

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true stamping id

Example responses

200 Response

{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "status": "recorded",
  "server_clock_at": "2020-06-04T14:58:49.303619Z",
  "id": "f4fded44-2717-485c-84b3-70982c696977",
  "direction": "IN",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2020-06-04T14:58:49.303613Z",
  "change_log": [],
  "badge_id": "8283876937",
  "approver_ids": []
}

Responses

Status Meaning Description Schema
200 OK Success Stamping

Renders a list of stamping areas for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/areas/by_company/{company_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.fluida.io/api/v1/stampings/areas/by_company/{company_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/areas/by_company/{company_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.fluida.io/api/v1/stampings/areas/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/areas/by_company/{company_id}

Renders a list of stamping areas for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id
subsidiary_id query string false subsidiary id

Example responses

200 Response

[
  {
    "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
    "radius": "50",
    "name": "Life Insurance",
    "long": "69.22462284381567",
    "lat": "17.57140909572334",
    "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
    "enabled": false,
    "detached": false,
    "description": "Health Care Providers",
    "contracts": [],
    "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
    "additional_details": {}
  }
]

Responses

Status Meaning Description Schema
200 OK Success StampingAreas

Renders a list stamping entries for a given approver contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/by_approver/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/by_approver/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/by_approver/{approver_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.fluida.io/api/v1/stampings/by_approver/{approver_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/by_approver/{approver_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.fluida.io/api/v1/stampings/by_approver/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/by_approver/{approver_id}

Renders a list stamping entries for a given approver contract id...

Parameters

Name In Type Required Description
approver_id path string true approver id
start_date query string false Start date
end_date query string false End date
status query string false Status
limit query string false limit

Example responses

200 Response

[
  {
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
    "team_ids": [],
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "status": "recorded",
    "server_clock_at": "2020-06-04T14:58:49.303619Z",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "direction": "IN",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "clock_tz": "Etc/UTC",
    "clock_type": "clock",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_at": "2020-06-04T14:58:49.303613Z",
    "change_log": [],
    "badge_id": "8283876937",
    "approver_ids": []
  }
]

Responses

Status Meaning Description Schema
200 OK Success Stampings

Rejects stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}',
  method: 'put',
  data: '?closer_id=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string',
{
  method: 'PUT',

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

require 'rest-client'
require 'json'

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

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}',
  params: {
  'closer_id' => 'string'
}, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}', params={
  'closer_id': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/{contract_id}/reject/{id}

Rejects stamping for a contract...

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true stamping id
closer_id query string true rejector id
rejector_notes query string false rejector notes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Updates chosen contract device

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/contracts/devices/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/contracts/devices/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/contracts/devices/{id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
  "name": "Fixed Line Telecommunications",
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "enabled": false,
  "device_info": {},
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "description": "Hotel & Lodging REITs",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/contracts/devices/{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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/contracts/devices/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/contracts/devices/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/contracts/devices/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/stampings/contracts/devices/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/contracts/devices/{id}

Updates chosen contract device...

Body parameter

{
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
  "name": "Fixed Line Telecommunications",
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "enabled": false,
  "device_info": {},
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "description": "Hotel & Lodging REITs",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
}

Parameters

Name In Type Required Description
id path string true contract device id
body body ContractDevice false contract device attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders a list of stampings to be approved by a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_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.fluida.io/api/v1/stampings/to_be_approved/{approver_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_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.fluida.io/api/v1/stampings/to_be_approved/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/to_be_approved/{approver_id}

Renders a list of stampings to be approved by a given contract id...

Parameters

Name In Type Required Description
approver_id path string true approver id
limit query string false limit

Example responses

200 Response

[
  {
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
    "team_ids": [],
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "status": "recorded",
    "server_clock_at": "2020-06-04T14:58:49.303619Z",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "direction": "IN",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "clock_tz": "Etc/UTC",
    "clock_type": "clock",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_at": "2020-06-04T14:58:49.303613Z",
    "change_log": [],
    "badge_id": "8283876937",
    "approver_ids": []
  }
]

Responses

Status Meaning Description Schema
200 OK Success Stampings

Approves stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}',
  method: 'put',
  data: '?closer_id=string',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string',
{
  method: 'PUT',

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

require 'rest-client'
require 'json'

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

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}',
  params: {
  'closer_id' => 'string'
}, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}', params={
  'closer_id': 'string'
}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/{contract_id}/approve/{id}

Approves stamping for a contract...

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true stamping id
closer_id query string true approver id
approver_notes query string false approver notes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Records a user stamping clock

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/{contract_id}/clock \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/{contract_id}/clock HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/{contract_id}/clock',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "sign": "signature",
  "server_clock_at": "2020-06-04T14:58:49.303497Z",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2020-06-04T14:58:49.303486Z",
  "badge_id": "8283876937",
  "approver_ids": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/stampings/{contract_id}/clock',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/{contract_id}/clock', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/{contract_id}/clock");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/stampings/{contract_id}/clock", data)
    req.Header = headers

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

POST /api/v1/stampings/{contract_id}/clock

Records a user stamping clock...

Body parameter

{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "sign": "signature",
  "server_clock_at": "2020-06-04T14:58:49.303497Z",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2020-06-04T14:58:49.303486Z",
  "badge_id": "8283876937",
  "approver_ids": []
}

Parameters

Name In Type Required Description
contract_id path string true contract id
body body StampingRequest false stamping attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
200 OK Ok None
401 Unauthorized Unauthorized Unauthorized

Renders a list of stamping device by device id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_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.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_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.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/devices/by_device_id/{device_id}

Renders a list of stamping device by device id...

Parameters

Name In Type Required Description
device_id path string true device id

Example responses

200 Response

[
  {
    "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
    "name": "Leisure Goods",
    "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
    "enabled": false,
    "device_type": "nfc",
    "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
    "description": "Tires",
    "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
  }
]

Responses

Status Meaning Description Schema
200 OK Success StampingDevices

Deletes a stamping area for a company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

var headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}',
  method: 'delete',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/{company_id}/areas/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}", data)
    req.Header = headers

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

DELETE /api/v1/stampings/{company_id}/areas/{id}

Deletes a stamping area for a company

Parameters

Name In Type Required Description
company_id path string true company id
id path string true area id

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Renders eid params

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/beacons/eid/params \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/beacons/eid/params HTTP/1.1
Host: api.fluida.io
Accept: application/json

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/beacons/eid/params',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

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

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

};

fetch('https://api.fluida.io/api/v1/stampings/beacons/eid/params',
{
  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.fluida.io/api/v1/stampings/beacons/eid/params',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/beacons/eid/params', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/beacons/eid/params");
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.fluida.io/api/v1/stampings/beacons/eid/params", data)
    req.Header = headers

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

GET /api/v1/stampings/beacons/eid/params

Renders eid params...

Example responses

200 Response

{
  "public_key": "string",
  "min_exponent": "string",
  "max_exponent": "string"
}

Responses

Status Meaning Description Schema
200 OK Success EidParams

Updates chosen stamping area

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/areas/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/areas/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/areas/{id}',
  method: 'put',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/areas/{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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/areas/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/areas/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/areas/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/stampings/areas/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/areas/{id}

Updates chosen stamping area...

Body parameter

{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}

Parameters

Name In Type Required Description
id path string true stamping area id
body body StampingArea false stamping area attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Registers a beacon

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/beacons \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/beacons HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/stampings/beacons',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "resolver_public_key": "string",
  "initial_eid": "string",
  "initial_clock": "string",
  "exponent": "string",
  "description": "string",
  "beacon_public_key": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'

};

fetch('https://api.fluida.io/api/v1/stampings/beacons',
{
  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' => '*/*',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.post 'https://api.fluida.io/api/v1/stampings/beacons',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/beacons', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/stampings/beacons");
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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/stampings/beacons", data)
    req.Header = headers

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

POST /api/v1/stampings/beacons

Registers a beacon...

Body parameter

{
  "resolver_public_key": "string",
  "initial_eid": "string",
  "initial_clock": "string",
  "exponent": "string",
  "description": "string",
  "beacon_public_key": "string"
}

Parameters

Name In Type Required Description
body body Beacon false beacon attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
401 Unauthorized Unauthorized Unauthorized

Updates a stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

var headers = {
  'Content-Type':'applica