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:

• https://api.fluida.io

Authentication

• oAuth2 authentication.

  • Flow: implicit
  • Authorization URL = https://app.fluida.io/oauth/authorize

Scope	Scope Description
write:schedule	Schedule write
read:expense_type	Expense type read
write:activity_types	Activity types write
write:expense_type	Expense type write
write:justification	Justification write
read:company_communication	Company communication read
write:request	Request write
write:workplace_override	Workplace override write
read:contract	Contract read
read:customer	Customer read
write:contract_day_schedule_change	Contract day schedule change write
write:company	Company write
write:activity_type	Activity type write
read:team	Team read
read:activity_type	Activity type read
write:customers	Customers write
write:justification_type	Justification type write
read:expense	Expense read
write:orders	Orders write
read:request	Request read
read:stamping	Stamping read
read:calendar	Calendar read
read:expense_report	Expense report read
read:justification	Justification read
write:activity	Activity write
write:company_communication	Company communication write
write:user_document	User document write
read:workplace_override	Workplace override read
write:expense_report	Expense report write
write:team	Team write
read:orders	Orders read
write:expense	Expense write
read:activity_types	Activity types read
write:stamping	Stamping write
read:export	Export read
read:order	Order read
write:activities	Activities write
read:holiday	Holiday read
write:stamping_device	Stamping device write
write:stamping_area	Stamping area write
read:schedule	Schedule read
write:customer	Customer write
write:contract	Contract write
read:stamping_area	Stamping area read
read:company	Company read
read:contract_day_schedule_change	Contract day schedule change read
write:holiday	Holiday write
read:customers	Customers read
read:user_document	User document read
read:activity	Activity read
read:company_communication_message	Company communication message read
read:justification_type	Justification type read
write:company_communication_message	Company communication message write
read:stamping_device	Stamping device read
write:export	Export write
read:activities	Activities read
write:order	Order write

• API Key (ApiKey)
  • Parameter Name: x-fluida-app-uuid, in: header. Api Key for authorized app

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: */*

const inputBody = '{
  "team_leader_ids": [
    "46568afb-1eab-447b-9289-c7ca989fbbe7",
    "8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
  ],
  "subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
  "name": "Thompson-Emard",
  "company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
  "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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/teams', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": [
    "46568afb-1eab-447b-9289-c7ca989fbbe7",
    "8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
  ],
  "subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
  "name": "Thompson-Emard",
  "company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
  "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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/teams', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": [
      "46568afb-1eab-447b-9289-c7ca989fbbe7",
      "8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
    ],
    "subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
    "name": "Thompson-Emard",
    "company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
    "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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/:company_id/communications', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/extension', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

const inputBody = '{
  "team_leader_ids": [
    "46568afb-1eab-447b-9289-c7ca989fbbe7",
    "8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
  ],
  "subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
  "name": "Thompson-Emard",
  "company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
  "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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": [
    "46568afb-1eab-447b-9289-c7ca989fbbe7",
    "8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
  ],
  "subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
  "name": "Thompson-Emard",
  "company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
  "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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/holidays', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/communications/:id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/:id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/fluida_extensions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/all_holidays', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

Creates a notification for holiday import

Code samples

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

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

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

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

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

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

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

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

Creates a notification for holiday import...

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

List fluida extensions related to a company

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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/extensions', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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...

Parameters

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

Example responses

200 Response

Responses

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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

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

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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": "8beeb818-a837-473a-bb55-a935720b6686",
  "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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": "8beeb818-a837-473a-bb55-a935720b6686",
  "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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": "8beeb818-a837-473a-bb55-a935720b6686",
    "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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/api_keys', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/api_keys', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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": "8beeb818-a837-473a-bb55-a935720b6686",
  "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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": "8beeb818-a837-473a-bb55-a935720b6686",
  "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

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": "8beeb818-a837-473a-bb55-a935720b6686",
  "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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": [
    "46568afb-1eab-447b-9289-c7ca989fbbe7",
    "8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
  ],
  "subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
  "name": "Thompson-Emard",
  "company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
  "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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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": [
    "ca83b036-04cc-48df-a367-d6375b94ddcd"
  ]
}

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

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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: */*

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', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/requests/{id}/approve', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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

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}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.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)
    // ...
}