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
read:customers Customers read
read:stamping Stamping read
read:activity Activity read
write:customer Customer write
write:activities Activities write
read:company Company read
write:company Company write
write:company_communication_message Company communication message write
write:company_communication Company communication write
write:workplace_override Workplace override write
read:contract Contract read
write:contract Contract write
read:expense_type Expense type read
read:expense_report Expense report read
write:schedule Schedule write
read:contract_day_schedule_change Contract day schedule change read
read:company_communication Company communication read
write:order Order write
read:justification_type Justification type read
read:expense Expense read
read:request Request read
read:activity_types Activity types read
write:stamping_area Stamping area write
write:activity_types Activity types write
write:justification_type Justification type write
write:stamping_device Stamping device write
write:request Request write
read:team Team read
read:customer Customer read
write:export Export write
read:holiday Holiday read
read:activity_type Activity type read
read:justification Justification read
read:order Order read
read:calendar Calendar read
read:schedule Schedule read
read:company_communication_message Company communication message read
write:activity Activity write
read:stamping_area Stamping area read
read:workplace_override Workplace override read
write:team Team write
read:user_document User document read
write:contract_day_schedule_change Contract day schedule change write
read:export Export read
write:justification Justification write
write:holiday Holiday write
write:activity_type Activity type write
write:user_document User document write
write:customers Customers write
write:orders Orders write
write:expense_type Expense type write
write:expense Expense write
write:stamping Stamping write
read:orders Orders read
read:activities Activities read
write:expense_report Expense report write
read:stamping_device Stamping device 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": [
    "abb97aaf-23b5-45c4-9723-3e5dc9685f3f",
    "348c6e8c-6b40-4cab-9cc1-cff6e83cc06c"
  ],
  "subsidiary_id": "ce936fe1-8dcb-442f-8972-a1b6a7e11467",
  "name": "Thompson-Emard",
  "company_id": "8477724d-846b-4537-944c-f4a9db825bff",
  "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": [
    "abb97aaf-23b5-45c4-9723-3e5dc9685f3f",
    "348c6e8c-6b40-4cab-9cc1-cff6e83cc06c"
  ],
  "subsidiary_id": "ce936fe1-8dcb-442f-8972-a1b6a7e11467",
  "name": "Thompson-Emard",
  "company_id": "8477724d-846b-4537-944c-f4a9db825bff",
  "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": [
      "abb97aaf-23b5-45c4-9723-3e5dc9685f3f",
      "348c6e8c-6b40-4cab-9cc1-cff6e83cc06c"
    ],
    "subsidiary_id": "ce936fe1-8dcb-442f-8972-a1b6a7e11467",
    "name": "Thompson-Emard",
    "company_id": "8477724d-846b-4537-944c-f4a9db825bff",
    "code": "47395 Gus Unions"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Teams

Get company extension status

Code samples

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

GET https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status 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/extension/:extension_id/status',
  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/extension/:extension_id/status',
{
  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/extension/:extension_id/status',
  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/extension/:extension_id/status', params={

}, headers = headers)

print r.json()

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

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

GET /api/v1/companies/:company_id/extension/:extension_id/status

Get company extension status...

Parameters

Name In Type Required Description
company_id path string true company_id
extension_id path string true extension_id

Example responses

200 Response

Responses

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

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
recurring query boolean false filter communications by recurring state

Example responses

200 Response

Responses

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

Updates a company extension

Code samples

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

PUT https://api.fluida.io/api/v1/companies/:company_id/extension 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/extension',
  method: 'put',

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

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

};

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

}, headers = headers)

print r.json()

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

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

PUT /api/v1/companies/:company_id/extension

Updates a company extension...

Body parameter

{
  "extension_id": "string",
  "extension_code": "string",
  "enabled": true,
  "configuration": {},
  "company_id": "string"
}

Parameters

Name In Type Required Description
company_id path string true company id
body body CompanyExtension false extension attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
202 Accepted Accepted None
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": [
    "abb97aaf-23b5-45c4-9723-3e5dc9685f3f",
    "348c6e8c-6b40-4cab-9cc1-cff6e83cc06c"
  ],
  "subsidiary_id": "ce936fe1-8dcb-442f-8972-a1b6a7e11467",
  "name": "Thompson-Emard",
  "company_id": "8477724d-846b-4537-944c-f4a9db825bff",
  "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": [
    "abb97aaf-23b5-45c4-9723-3e5dc9685f3f",
    "348c6e8c-6b40-4cab-9cc1-cff6e83cc06c"
  ],
  "subsidiary_id": "ce936fe1-8dcb-442f-8972-a1b6a7e11467",
  "name": "Thompson-Emard",
  "company_id": "8477724d-846b-4537-944c-f4a9db825bff",
  "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

List fluida extensions

Code samples

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

GET https://api.fluida.io/api/v1/fluida_extensions HTTP/1.1
Host: api.fluida.io
Accept: */*

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

};

$.ajax({
  url: 'https://api.fluida.io/api/v1/fluida_extensions',
  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/fluida_extensions',
{
  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/fluida_extensions',
  params: {
  }, headers: headers

p JSON.parse(result)

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

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

}, headers = headers)

print r.json()

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

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

GET /api/v1/fluida_extensions

List fluida extensions...

Parameters

Name In Type Required Description
category query string false filter by category

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success FluidaExtensions
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

Code samples

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

GET https://api.fluida.io/api/v1/companies/:company_id/extensions 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/extensions',
  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/extensions',
{
  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/extensions',
  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/extensions', params={

}, headers = headers)

print r.json()

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

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

GET /api/v1/companies/:company_id/extensions

List fluida extensions related to a company...

Name In Type Required Description
category path string true company_id
enabled query boolean false filter by enabled

Example responses

200 Response

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

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

Get company extension

Code samples

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

GET https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_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/extension/:extension_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/extension/:extension_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/extension/:extension_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/extension/:extension_id', params={

}, headers = headers)

print r.json()

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

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

GET /api/v1/companies/:company_id/extension/:extension_id

Get company extension...

Parameters

Name In Type Required Description
company_id path string true company_id
extension_id path string true extension_id

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK Success CompanyExtension
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": "d64460b5-5d56-4c7c-8013-c8f47b9b37b8",
  "city": "Port Holdenville",
  "capacity": 4,
  "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": "d64460b5-5d56-4c7c-8013-c8f47b9b37b8",
  "city": "Port Holdenville",
  "capacity": 4,
  "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
name query string false subsidiary name

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": "d64460b5-5d56-4c7c-8013-c8f47b9b37b8",
    "city": "Port Holdenville",
    "capacity": 4,
    "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": "d64460b5-5d56-4c7c-8013-c8f47b9b37b8",
  "city": "Port Holdenville",
  "capacity": 4,
  "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": "d64460b5-5d56-4c7c-8013-c8f47b9b37b8",
  "city": "Port Holdenville",
  "capacity": 4,
  "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": "d64460b5-5d56-4c7c-8013-c8f47b9b37b8",
  "city": "Port Holdenville",
  "capacity": 4,
  "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": [
    "abb97aaf-23b5-45c4-9723-3e5dc9685f3f",
    "348c6e8c-6b40-4cab-9cc1-cff6e83cc06c"
  ],
  "subsidiary_id": "ce936fe1-8dcb-442f-8972-a1b6a7e11467",
  "name": "Thompson-Emard",
  "company_id": "8477724d-846b-4537-944c-f4a9db825bff",
  "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 PUT https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{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}/api_keys/{id}',
  method: 'put',

  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/{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}/api_keys/{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}/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("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}/api_keys/{id}", data)
    req.Header = headers

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

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

Updates 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
id path string true api key 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

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

Deletes 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}

Deletes 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

Request

Renders a set of approvers by entity and contract

Code samples

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

GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_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/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_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/requests/{company_id}/{entity_type}/approvers/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' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_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/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}', params={

}, headers = headers)

print r.json()

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

    }

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

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

GET /api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}

Renders a set of approvers by entity and contract...

Parameters

Name In Type Required Description
company_id path string true company id
entity_type path string true entity type
contract_id path string true contract id

Example responses

200 Response

{
  "approver_ids": [
    "3c3dfad9-01db-4289-ba98-d188e202b5ed"
  ]
}

Responses

Status Meaning Description Schema
200 OK Success Approvers

Renders a request by entity

Code samples

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

GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_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/requests/{company_id}/{entity_type}/entity_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/requests/{company_id}/{entity_type}/entity_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/requests/{company_id}/{entity_type}/entity_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/requests/{company_id}/{entity_type}/entity_id', params={

}, headers = headers)

print r.json()

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

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

GET /api/v1/requests/{company_id}/{entity_type}/entity_id

Renders a request by entity...

Parameters

Name In Type Required Description
company_id path string true company id
entity_type path string true entity type
entity_id path string true entity id

Example responses

200 Response

{
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "entity_type": "justification",
  "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
  "entity_data": {
    "type_name": "adipisci",
    "type_label": "quia",
    "type_id": "holiday",
    "to_time": "12:00:00",
    "to_date": "2019-03-02",
    "status": "requested",
    "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
    "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
    "from_time": "10:00:00",
    "from_date": "2019-02-26",
    "followers_ids": [
      "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
      "e80ee330-aa3a-4f8d-be8f-748869705b5d"
    ],
    "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
    "approvers_ids": [
      "13d2371a-326d-4b96-912f-c20f2c2cef15"
    ]
  },
  "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
}

Responses

Status Meaning Description Schema
200 OK Success Request

Approves a request

Code samples

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

POST https://api.fluida.io/api/v1/requests/{id}/approve 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/requests/{id}/approve',
  method: 'post',

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

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

};

fetch('https://api.fluida.io/api/v1/requests/{id}/approve',
{
  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/requests/{id}/approve',
  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/requests/{id}/approve', params={

}, headers = headers)

print r.json()

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

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

POST /api/v1/requests/{id}/approve

Approves a request...

Body parameter

false

Parameters

Name In Type Required Description
id path string true request id

Example responses

401 Response

Responses

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

Renders a list of requests for an approver contract

Code samples

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

GET https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_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/requests/{company_id}/by_approver/{approver_contract_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/requests/{company_id}/by_approver/{approver_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' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_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/requests/{company_id}/by_approver/{approver_contract_id}', params={

}, headers = headers)

print r.json()

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

    }

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

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

GET /api/v1/requests/{company_id}/by_approver/{approver_contract_id}

Renders a list of requests for an approver_contract...

Parameters

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

Example responses

200 Response

[
  {
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
    "entity_type": "justification",
    "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
    "entity_data": {
      "type_name": "adipisci",
      "type_label": "quia",
      "type_id": "holiday",
      "to_time": "12:00:00",
      "to_date": "2019-03-02",
      "status": "requested",
      "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
      "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
      "from_time": "10:00:00",
      "from_date": "2019-02-26",
      "followers_ids": [
        "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
        "e80ee330-aa3a-4f8d-be8f-748869705b5d"
      ],
      "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
      "approvers_ids": [
        "13d2371a-326d-4b96-912f-c20f2c2cef15"
      ]
    },
    "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Requests

Renders a request

Code samples

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

GET https://api.fluida.io/api/v1/requests/{company_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/requests/{company_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/requests/{company_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/requests/{company_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/requests/{company_id}/{id}', params={

}, headers = headers)

print r.json()

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

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

GET /api/v1/requests/{company_id}/{id}

Renders a request...

Parameters

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

Example responses

200 Response

{
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "entity_type": "justification",
  "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
  "entity_data": {
    "type_name": "adipisci",
    "type_label": "quia",
    "type_id": "holiday",
    "to_time": "12:00:00",
    "to_date": "2019-03-02",
    "status": "requested",
    "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
    "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
    "from_time": "10:00:00",
    "from_date": "2019-02-26",
    "followers_ids": [
      "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
      "e80ee330-aa3a-4f8d-be8f-748869705b5d"
    ],
    "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
    "approvers_ids": [
      "13d2371a-326d-4b96-912f-c20f2c2cef15"
    ]
  },
  "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
}

Responses

Status Meaning Description Schema
200 OK Success Request

Rejects a request

Code samples

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

PUT https://api.fluida.io/api/v1/requests/{id}/reject 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/requests/{id}/reject',
  method: 'put',

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

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

};

fetch('https://api.fluida.io/api/v1/requests/{id}/reject',
{
  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/requests/{id}/reject',
  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/requests/{id}/reject', params={

}, headers = headers)

print r.json()

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

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

PUT /api/v1/requests/{id}/reject

Rejects a request...

Body parameter

false

Parameters

Name In Type Required Description
id path string true request id

Example responses

401 Response

Responses

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

Renders a list of requests for a contract

Code samples

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

GET https://api.fluida.io/api/v1/requests/{company_id}/by_contract/{contract_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/requests/{company_id}/by_contract/{contract_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/requests/{company_id}/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' => 'application/json',
  'Authorization' => 'Bearer {access-token}'
}

result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/by_contract/{contract_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/requests/{company_id}/by_contract/{contract_id}', params={

}, headers = headers)

print r.json()

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

    }

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

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

GET /api/v1/requests/{company_id}/by_contract/{contract_id}

Renders a list of requests for a contract...

Parameters

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

Example responses

200 Response

[
  {
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
    "entity_type": "justification",
    "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
    "entity_data": {
      "type_name": "adipisci",
      "type_label": "quia",
      "type_id": "holiday",
      "to_time": "12:00:00",
      "to_date": "2019-03-02",
      "status": "requested",
      "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
      "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
      "from_time": "10:00:00",
      "from_date": "2019-02-26",
      "followers_ids": [
        "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
        "e80ee330-aa3a-4f8d-be8f-748869705b5d"
      ],
      "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
      "approvers_ids": [
        "13d2371a-326d-4b96-912f-c20f2c2cef15"
      ]
    },
    "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Requests

Renders a set of approvers by entity

Code samples

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

GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_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/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_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/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_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/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_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/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_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/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id}", data)
    req.Header = headers

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

GET /api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id}

Renders a set of approvers by entity...

Parameters

Name In Type Required Description
company_id path string true company id
entity_type path string true entity type
entity_id path string true entity id

Example responses

200 Response

{
  "approver_ids": [
    "3c3dfad9-01db-4289-ba98-d188e202b5ed"
  ]
}

Responses

Status Meaning Description Schema
200 OK Success Approvers

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 InputSt