NAV Navbar
Shell HTTP JavaScript Ruby Python PHP Java Go

Fluida API v1.0.0

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

Fluida API integration guide

Base URLs:

Authentication

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

Subscription

Return Subscription management page

Code samples

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

GET https://api.fluida.io/api/v1/subscription/{company_id}/manager_page/?redirect_url=string 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/subscription/{company_id}/manager_page/?redirect_url=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/{company_id}/manager_page/',
  params: {
  'redirect_url' => 'string'
}, 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/subscription/{company_id}/manager_page/', params={
  'redirect_url': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/{company_id}/manager_page/', 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/subscription/{company_id}/manager_page/?redirect_url=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/subscription/{company_id}/manager_page/

Return Subscription management page

Parameters

Name In Type Required Description
company_id path string true Company ID
redirect_url query string true Redirect url

Example responses

200 Response

{
  "url": "https://foo.bar/manager/",
  "expires_at": 1571669005
}

Responses

Status Meaning Description Schema
200 OK Success SubscriptionManagerPage
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found NotFound

Cancel subscription

Code samples

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

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

const inputBody = '{
  "cancellation_reason": "other",
  "cancellation_message": "Too good to be used!"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/subscription/{company_id}/cancel',
{
  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/subscription/{company_id}/cancel',
  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/subscription/{company_id}/cancel', 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/subscription/{company_id}/cancel', 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/subscription/{company_id}/cancel");
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/subscription/{company_id}/cancel", data)
    req.Header = headers

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

PUT /api/v1/subscription/{company_id}/cancel

Cancel subscription

Body parameter

{
  "cancellation_reason": "other",
  "cancellation_message": "Too good to be used!"
}

Parameters

Name In Type Required Description
company_id path string true subscription id
body body SubscriptionCancellationData false cancellation attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
200 OK Accepted None
401 Unauthorized Unauthorized Unauthorized

Response Schema

Remove subscription scheduled Cancellation

Code samples

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

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


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

fetch('https://api.fluida.io/api/v1/subscription/{company_id}/remove_scheduled_cancellation/{subscription_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/subscription/{company_id}/remove_scheduled_cancellation/{subscription_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/subscription/{company_id}/remove_scheduled_cancellation/{subscription_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/subscription/{company_id}/remove_scheduled_cancellation/{subscription_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/subscription/{company_id}/remove_scheduled_cancellation/{subscription_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/subscription/{company_id}/remove_scheduled_cancellation/{subscription_id}", data)
    req.Header = headers

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

PUT /api/v1/subscription/{company_id}/remove_scheduled_cancellation/{subscription_id}

Remove subscription scheduled Cancellation

Parameters

Name In Type Required Description
company_id path string true company id
subscription_id path string true subscription id

Example responses

401 Response

Responses

Status Meaning Description Schema
200 OK OK None
401 Unauthorized Unauthorized Unauthorized

Response Schema

Creates a subscription plan

Code samples

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

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

const inputBody = '{
  "plan": {
    "sku": "starter",
    "price": 2,
    "plan_family": "starter",
    "period_unit": "month",
    "name": "Starter",
    "features": [
      "export"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/subscription/plans',
{
  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/subscription/plans',
  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/subscription/plans', 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/subscription/plans', 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/subscription/plans");
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/subscription/plans", data)
    req.Header = headers

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

POST /api/v1/subscription/plans

Creates a subscription plan

Body parameter

{
  "plan": {
    "sku": "starter",
    "price": 2,
    "plan_family": "starter",
    "period_unit": "month",
    "name": "Starter",
    "features": [
      "export"
    ]
  }
}

Parameters

Name In Type Required Description
body body Plan false plan attributes

Example responses

401 Response

Responses

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

List of subscription plans

Code samples

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

GET https://api.fluida.io/api/v1/subscription/plans 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/subscription/plans',
{
  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/subscription/plans',
  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/subscription/plans', 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/subscription/plans', 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/subscription/plans");
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/subscription/plans", data)
    req.Header = headers

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

GET /api/v1/subscription/plans

Renders a list of subscription plans optionally filtered by name

Parameters

Name In Type Required Description
name query string false plan name

Example responses

200 Response

[
  {
    "plan": {
      "sku": "starter",
      "price": 2,
      "plan_family": "starter",
      "period_unit": "month",
      "name": "Starter",
      "features": [
        "export"
      ]
    }
  }
]

Responses

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

update subscription plan

Code samples

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

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


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

fetch('https://api.fluida.io/api/v1/subscription/companies/{company_id}/update/{subscription_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/subscription/companies/{company_id}/update/{subscription_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/subscription/companies/{company_id}/update/{subscription_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/subscription/companies/{company_id}/update/{subscription_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/subscription/companies/{company_id}/update/{subscription_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/subscription/companies/{company_id}/update/{subscription_id}", data)
    req.Header = headers

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

PUT /api/v1/subscription/companies/{company_id}/update/{subscription_id}

update subscription plan

Parameters

Name In Type Required Description
subscription_id path string true subscription id
company_id path string true company id

Example responses

401 Response

Responses

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

Response Schema

Get subscription plan by id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/subscription/plans/{id} \
  -H 'Accept: application/json'

GET https://api.fluida.io/api/v1/subscription/plans/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


const headers = {
  'Accept':'application/json'
};

fetch('https://api.fluida.io/api/v1/subscription/plans/{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'
}

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/plans/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.fluida.io/api/v1/subscription/plans/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/plans/{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/subscription/plans/{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"},
    }

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

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

GET /api/v1/subscription/plans/{id}

Renders subscription plan by id

Parameters

Name In Type Required Description
id path string true plan id

Example responses

200 Response

{
  "plan": {
    "sku": "starter",
    "price": 2,
    "plan_family": "starter",
    "period_unit": "month",
    "name": "Starter",
    "features": [
      "export"
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK Success Plan
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found Notfound

Get company subscription details

Code samples

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

GET https://api.fluida.io/api/v1/subscription/{company_id}/details 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/subscription/{company_id}/details',
{
  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/subscription/{company_id}/details',
  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/subscription/{company_id}/details', 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/subscription/{company_id}/details', 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/subscription/{company_id}/details");
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/subscription/{company_id}/details", data)
    req.Header = headers

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

GET /api/v1/subscription/{company_id}/details

Get company subscription details

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status Meaning Description Schema
200 OK Success None
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found Notfound

Response Schema

Estimate Subscription

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/subscription/:subscription_id/estimate?company_id=string&product_sku=string&subscription_plan=string&plan_quantity=0

GET https://api.fluida.io/api/v1/subscription/:subscription_id/estimate?company_id=string&product_sku=string&subscription_plan=string&plan_quantity=0 HTTP/1.1
Host: api.fluida.io


fetch('https://api.fluida.io/api/v1/subscription/:subscription_id/estimate?company_id=string&product_sku=string&subscription_plan=string&plan_quantity=0',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/:subscription_id/estimate',
  params: {
  'company_id' => 'string',
'product_sku' => 'string',
'subscription_plan' => 'string',
'plan_quantity' => 'integer'
}

p JSON.parse(result)

import requests

r = requests.get('https://api.fluida.io/api/v1/subscription/:subscription_id/estimate', params={
  'company_id': 'string',  'product_sku': 'string',  'subscription_plan': 'string',  'plan_quantity': '0'
})

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/:subscription_id/estimate', 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/subscription/:subscription_id/estimate?company_id=string&product_sku=string&subscription_plan=string&plan_quantity=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

GET /api/v1/subscription/:subscription_id/estimate

Check if coupon is valid...

Parameters

Name In Type Required Description
subscription_id path string true subscription_id
company_id query string true company_id
product_sku query string true product sku
subscription_plan query string true subscription plan
plan_quantity query integer true plan quantity
coupon_code query string false coupon code
addons query array[string] false addon ids

Responses

Status Meaning Description Schema
200 OK Success None

Return Subscription Portal Session

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/portal/?redirect_url=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/portal/?redirect_url=string 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/subscription/{subscription_customer_id}/portal/?redirect_url=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/portal/',
  params: {
  'redirect_url' => 'string'
}, 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/subscription/{subscription_customer_id}/portal/', params={
  'redirect_url': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/portal/', 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/subscription/{subscription_customer_id}/portal/?redirect_url=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/subscription/{subscription_customer_id}/portal/

Return Subscription Portal Session

Parameters

Name In Type Required Description
subscription_customer_id path string true Subscription Customer Id
redirect_url query string true Redirect url

Example responses

200 Response

{
  "token": "A6ffqiHBYcuMX3ZKDW9pQWVDzoyUzpcuf0",
  "status": "created",
  "redirect_url": "https://app.fluida.io",
  "object": "portal_session",
  "id": "portal_HrV2Na0RVdkxy61I7C",
  "expires_at": 1562597549,
  "customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "created_at": 1562593949,
  "access_url": "https://fluida-test.chargebee.com/portal/v2/authenticate?token=A6ffqiHBYcuMX3ZKDW9pQWVDzoyUzpcuf0"
}

Responses

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

Return Subscription payment management page

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/payment_page/?redirect_url=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/payment_page/?redirect_url=string 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/subscription/{subscription_customer_id}/payment_page/?redirect_url=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/payment_page/',
  params: {
  'redirect_url' => 'string'
}, 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/subscription/{subscription_customer_id}/payment_page/', params={
  'redirect_url': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/{subscription_customer_id}/payment_page/', 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/subscription/{subscription_customer_id}/payment_page/?redirect_url=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/subscription/{subscription_customer_id}/payment_page/

Return Subscription payment management page

Parameters

Name In Type Required Description
subscription_customer_id path string true Subscription Customer Id
redirect_url query string true Redirect url

Example responses

200 Response

{
  "url": "https://fluida-test.chargebee.com/pages/v3/ZXZmwctF4cQbXrbygB1QsAYMUiVUVJFz/",
  "updated_at": 1571237005,
  "type": "manage_payment_sources",
  "state": "created",
  "resource_version": 1571237005272,
  "object": "hosted_page",
  "id": "ZXZmwctF4cQbXrbygB1QsAYMUiVUVJFz",
  "expires_at": 1571669005,
  "embed": false,
  "created_at": 1571237005
}

Responses

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

Creates a Product

Code samples

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

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

const inputBody = '{
  "product": {
    "visible": true,
    "subscription_manager": "chargebee",
    "sku": "fluida-page",
    "name": "Fluida Paghe",
    "allowed_plans": [
      "fluida-paghe-self",
      "fluida-paghe-full"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/subscription/products',
{
  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/subscription/products',
  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/subscription/products', 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/subscription/products', 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/subscription/products");
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/subscription/products", data)
    req.Header = headers

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

POST /api/v1/subscription/products

Creates a Product

Body parameter

{
  "product": {
    "visible": true,
    "subscription_manager": "chargebee",
    "sku": "fluida-page",
    "name": "Fluida Paghe",
    "allowed_plans": [
      "fluida-paghe-self",
      "fluida-paghe-full"
    ]
  }
}

Parameters

Name In Type Required Description
body body Product false Product attributes

Example responses

401 Response

Responses

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

List of products

Code samples

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

GET https://api.fluida.io/api/v1/subscription/products 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/subscription/products',
{
  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/subscription/products',
  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/subscription/products', 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/subscription/products', 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/subscription/products");
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/subscription/products", data)
    req.Header = headers

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

GET /api/v1/subscription/products

Renders a filtered list of products

Parameters

Name In Type Required Description
category query string false category
brand query string false brand
visible query string false visible

Example responses

200 Response

[
  {
    "product": {
      "visible": true,
      "subscription_manager": "chargebee",
      "sku": "fluida-page",
      "name": "Fluida Paghe",
      "allowed_plans": [
        "fluida-paghe-self",
        "fluida-paghe-full"
      ]
    }
  }
]

Responses

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

Get company subscription status

Code samples

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

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

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/{company_id}/status',
  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/subscription/{company_id}/status', 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/subscription/{company_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/subscription/{company_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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

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

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

GET /api/v1/subscription/{company_id}/status

Get company subscription status

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status Meaning Description Schema
200 OK Success None
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found Notfound

Response Schema

update product

Code samples

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

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

const inputBody = '{
  "product": {
    "visible": true,
    "subscription_manager": "chargebee",
    "sku": "fluida-page",
    "name": "Fluida Paghe",
    "allowed_plans": [
      "fluida-paghe-self",
      "fluida-paghe-full"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/subscription/products/{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/subscription/products/{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/subscription/products/{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/subscription/products/{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/subscription/products/{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/subscription/products/{id}", data)
    req.Header = headers

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

PUT /api/v1/subscription/products/{id}

update product

Body parameter

{
  "product": {
    "visible": true,
    "subscription_manager": "chargebee",
    "sku": "fluida-page",
    "name": "Fluida Paghe",
    "allowed_plans": [
      "fluida-paghe-self",
      "fluida-paghe-full"
    ]
  }
}

Parameters

Name In Type Required Description
id path string true product id
body body Product false product attributes

Example responses

401 Response

Responses

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

Get product by id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/subscription/products/{id} \
  -H 'Accept: application/json'

GET https://api.fluida.io/api/v1/subscription/products/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


const headers = {
  'Accept':'application/json'
};

fetch('https://api.fluida.io/api/v1/subscription/products/{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'
}

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/products/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.fluida.io/api/v1/subscription/products/{id}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/products/{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/subscription/products/{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"},
    }

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

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

GET /api/v1/subscription/products/{id}

Renders product by id

Parameters

Name In Type Required Description
id path string true product id

Example responses

200 Response

{
  "product": {
    "visible": true,
    "subscription_manager": "chargebee",
    "sku": "fluida-page",
    "name": "Fluida Paghe",
    "allowed_plans": [
      "fluida-paghe-self",
      "fluida-paghe-full"
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK Success Product
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found Notfound

Get subscription plan by sku

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/subscription/plans/by_sku/{sku} \
  -H 'Accept: application/json'

GET https://api.fluida.io/api/v1/subscription/plans/by_sku/{sku} HTTP/1.1
Host: api.fluida.io
Accept: application/json


const headers = {
  'Accept':'application/json'
};

fetch('https://api.fluida.io/api/v1/subscription/plans/by_sku/{sku}',
{
  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'
}

result = RestClient.get 'https://api.fluida.io/api/v1/subscription/plans/by_sku/{sku}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.fluida.io/api/v1/subscription/plans/by_sku/{sku}', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/subscription/plans/by_sku/{sku}', 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/subscription/plans/by_sku/{sku}");
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"},
    }

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

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

GET /api/v1/subscription/plans/by_sku/{sku}

Renders subscription plan by sku

Parameters

Name In Type Required Description
sku path string true plan sku

Example responses

200 Response

{
  "plan": {
    "sku": "starter",
    "price": 2,
    "plan_family": "starter",
    "period_unit": "month",
    "name": "Starter",
    "features": [
      "export"
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK Success Plan
401 Unauthorized Unauthorized Unauthorized
404 Not Found Not Found Notfound

Check if coupon is valid

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/coupon_check/:coupon

GET https://api.fluida.io/api/v1/coupon_check/:coupon HTTP/1.1
Host: api.fluida.io


fetch('https://api.fluida.io/api/v1/coupon_check/:coupon',
{
  method: 'GET'

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

require 'rest-client'
require 'json'

result = RestClient.get 'https://api.fluida.io/api/v1/coupon_check/:coupon',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.get('https://api.fluida.io/api/v1/coupon_check/:coupon')

print(r.json())

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/coupon_check/:coupon', 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/coupon_check/:coupon");
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() {

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

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

GET /api/v1/coupon_check/:coupon

Check if coupon is valid...

Parameters

Name In Type Required Description
coupon path string true coupon
subscription_id path string true subscription_id

Responses

Status Meaning Description Schema
200 OK Success None

Approval

Renders an Approval Chain Template for a given id

Code samples

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

GET https://api.fluida.io/api/v1/approvals/{company_id}/approval_chain_templates/{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/approvals/{company_id}/approval_chain_templates/{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/approvals/{company_id}/approval_chain_templates/{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/approvals/{company_id}/approval_chain_templates/{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/approvals/{company_id}/approval_chain_templates/{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/approvals/{company_id}/approval_chain_templates/{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/approvals/{company_id}/approval_chain_templates/{id}", data)
    req.Header = headers

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

GET /api/v1/approvals/{company_id}/approval_chain_templates/{id}

Renders an Approval Chain Template for a given id.

Parameters

Name In Type Required Description
company_id path string true company id
id path string true approval chain template id

Example responses

200 Response

{
  "steps": [],
  "name": "Test",
  "mode": "and",
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "default": false,
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
}

Responses

Status Meaning Description Schema
200 OK Success ApprovalChainTemplate

Renders an Contract Approval Chain Override for a given id

Code samples

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

GET https://api.fluida.io/api/v1/approvals/{company_id}/contract_approval_chain_overrides/{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/approvals/{company_id}/contract_approval_chain_overrides/{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/approvals/{company_id}/contract_approval_chain_overrides/{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/approvals/{company_id}/contract_approval_chain_overrides/{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/approvals/{company_id}/contract_approval_chain_overrides/{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/approvals/{company_id}/contract_approval_chain_overrides/{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/approvals/{company_id}/contract_approval_chain_overrides/{id}", data)
    req.Header = headers

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

GET /api/v1/approvals/{company_id}/contract_approval_chain_overrides/{id}

Renders an Contract Approval Chain Override for a given id.

Parameters

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

Example responses

200 Response

{
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "entity_type": "justification",
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "approval_chain_template_id": "81c87dce-6451-4742-987e-05e27e76e93e"
}

Responses

Status Meaning Description Schema
200 OK Success ContractApprovalChainOverride

Renders an Default Approval Chain for a given id

Code samples

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

GET https://api.fluida.io/api/v1/approvals/{company_id}/default_approval_chains/{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/approvals/{company_id}/default_approval_chains/{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/approvals/{company_id}/default_approval_chains/{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/approvals/{company_id}/default_approval_chains/{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/approvals/{company_id}/default_approval_chains/{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/approvals/{company_id}/default_approval_chains/{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/approvals/{company_id}/default_approval_chains/{id}", data)
    req.Header = headers

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

GET /api/v1/approvals/{company_id}/default_approval_chains/{id}

Renders an Default Approval Chain for a given id.

Parameters

Name In Type Required Description
company_id path string true company id
id path string true approval chain template id

Example responses

200 Response

{
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "entity_type": "justification",
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "approval_chain_template_id": "81c87dce-6451-4742-987e-05e27e76e93e"
}

Responses

Status Meaning Description Schema
200 OK Success DefaultApprovalChain

Renders a list of Default Approval Chains for a given company

Code samples

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

GET https://api.fluida.io/api/v1/approvals/{company_id}/default_approval_chains 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/approvals/{company_id}/default_approval_chains',
{
  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/approvals/{company_id}/default_approval_chains',
  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/approvals/{company_id}/default_approval_chains', 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/approvals/{company_id}/default_approval_chains', 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/approvals/{company_id}/default_approval_chains");
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/approvals/{company_id}/default_approval_chains", data)
    req.Header = headers

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

GET /api/v1/approvals/{company_id}/default_approval_chains

Renders a list of Default Approval Chains for a given company.

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
    "entity_type": "justification",
    "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
    "approval_chain_template_id": "81c87dce-6451-4742-987e-05e27e76e93e"
  }
]

Responses

Status Meaning Description Schema
200 OK Success DefaultApprovalChains

Renders a list of Approval Chain Templates for a given company

Code samples

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

GET https://api.fluida.io/api/v1/approvals/{company_id}/approval_chain_templates 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/approvals/{company_id}/approval_chain_templates',
{
  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/approvals/{company_id}/approval_chain_templates',
  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/approvals/{company_id}/approval_chain_templates', 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/approvals/{company_id}/approval_chain_templates', 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/approvals/{company_id}/approval_chain_templates");
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/approvals/{company_id}/approval_chain_templates", data)
    req.Header = headers

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

GET /api/v1/approvals/{company_id}/approval_chain_templates

Renders a list of Approval Chain Templates for a given company.

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "steps": [],
    "name": "Test",
    "mode": "and",
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
    "default": false,
    "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
  }
]

Responses

Status Meaning Description Schema
200 OK Success ApprovalChainTemplates

Stamping

Renders a list stamping entries for a given approver contract id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/by_approver/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


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

fetch('https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}', 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/stampings/by_approver/{approver_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/stampings/by_approver/{approver_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/by_approver/{approver_id}

Renders a list stamping entries for a given approver contract id...

Parameters

Name In Type Required Description
approver_id path string true approver id
start_date query string false Start date
end_date query string false End date
status query string false Status
limit query string false limit

Example responses

200 Response

[
  {
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
    "team_ids": [],
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "status": "recorded",
    "server_clock_at": "2023-11-27T13:24:27.090296Z",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "direction": "IN",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "clock_tz": "Etc/UTC",
    "clock_type": "clock",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_at": "2023-11-27T13:24:27.090293Z",
    "change_log": [],
    "badge_id": "8283876937",
    "approver_ids": []
  }
]

Responses

Status Meaning Description Schema
200 OK Success Stampings

Renders contract last record

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{company_id}/contract_last_record 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/stampings/{company_id}/contract_last_record',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/contract_last_record', 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/stampings/{company_id}/contract_last_record', 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/stampings/{company_id}/contract_last_record");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{company_id}/contract_last_record

Renders contract last record...

Parameters

Name In Type Required Description
company_id path string true company id
contract_id query string false Contract id
day query string false Day

Example responses

200 Response

{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "status": "recorded",
  "server_clock_at": "2023-11-27T13:24:27.090296Z",
  "id": "f4fded44-2717-485c-84b3-70982c696977",
  "direction": "IN",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2023-11-27T13:24:27.090293Z",
  "change_log": [],
  "badge_id": "8283876937",
  "approver_ids": []
}

Responses

Status Meaning Description Schema
200 OK Success Stamping

Renders clock record by id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


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

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}', 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/stampings/{contract_id}/get/{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/stampings/{contract_id}/get/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{contract_id}/get/{id}

Renders clock record by id.

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true stamping id

Example responses

200 Response

{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "status": "recorded",
  "server_clock_at": "2023-11-27T13:24:27.090296Z",
  "id": "f4fded44-2717-485c-84b3-70982c696977",
  "direction": "IN",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2023-11-27T13:24:27.090293Z",
  "change_log": [],
  "badge_id": "8283876937",
  "approver_ids": []
}

Responses

Status Meaning Description Schema
200 OK Success Stamping

Updates a stamping for a contract

Code samples

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

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

const inputBody = '{
  "updated_by": "string",
  "subsidiary_id": "string",
  "notes": "string",
  "direction": "string",
  "clock_tz": "string",
  "clock_at": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

PUT /api/v1/stampings/{contract_id}/clock/{id}

Updates a stamping for a contract

Body parameter

{
  "updated_by": "string",
  "subsidiary_id": "string",
  "notes": "string",
  "direction": "string",
  "clock_tz": "string",
  "clock_at": "string"
}

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true clock id
body body StampingUpdate false stamping attributes

Example responses

401 Response

Responses

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

Deletes a stamping for a contract

Code samples

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

DELETE https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*


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

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

result = RestClient.delete 'https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

DELETE /api/v1/stampings/{contract_id}/clock/{id}

Deletes a stamping for a contract

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true clock id

Example responses

401 Response

Responses

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

Renders a list of stamping areas for a given company id

Code samples

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

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


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

fetch('https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}', 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/stampings/areas/by_company/{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/stampings/areas/by_company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/areas/by_company/{company_id}

Renders a list of stamping areas for a given company id...

Parameters

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

Example responses

200 Response

[
  {
    "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
    "radius": "50",
    "name": "Life Insurance",
    "long": "69.22462284381567",
    "lat": "17.57140909572334",
    "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
    "enabled": false,
    "detached": false,
    "description": "Health Care Providers",
    "contracts": [],
    "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
    "additional_details": {}
  }
]

Responses

Status Meaning Description Schema
200 OK Success StampingAreas

Renders a list of contract devices for a given company id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{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/stampings/contracts/devices/by_company/{company_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{company_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{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/stampings/contracts/devices/by_company/{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/stampings/contracts/devices/by_company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/contracts/devices/by_company/{company_id}

Renders a list of contract devices for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
    "name": "Fixed Line Telecommunications",
    "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
    "enabled": false,
    "device_info": {},
    "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
    "description": "Hotel & Lodging REITs",
    "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
    "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
  }
]

Responses

Status Meaning Description Schema
200 OK Success ContractDevices

Deletes a stamping area for a company

Code samples

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

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


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

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

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}', 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/stampings/{company_id}/areas/{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/stampings/{company_id}/areas/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

DELETE /api/v1/stampings/{company_id}/areas/{id}

Deletes a stamping area for a company

Parameters

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

Example responses

401 Response

Responses

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

Renders a company stamping device

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


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

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}', 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/stampings/{company_id}/devices/by_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/stampings/{company_id}/devices/by_id/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{company_id}/devices/by_id/{id}

Renders a company stamping device...

Parameters

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

Example responses

200 Response

{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}

Responses

Status Meaning Description Schema
200 OK Success StampingDevice

Create stamping device

Code samples

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

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

const inputBody = '{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/devices',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/devices', 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/stampings/devices', 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/stampings/devices");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/stampings/devices

Create stamping device...

Body parameter

{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}

Parameters

Name In Type Required Description
body body StampingDevice false stamping device attributes

Example responses

401 Response

Responses

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

Renders a list of stamping device by device id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


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

fetch('https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}', 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/stampings/devices/by_device_id/{device_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/stampings/devices/by_device_id/{device_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/devices/by_device_id/{device_id}

Renders a list of stamping device by device id...

Parameters

Name In Type Required Description
device_id path string true device id

Example responses

200 Response

[
  {
    "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
    "name": "Leisure Goods",
    "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
    "enabled": false,
    "device_type": "nfc",
    "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
    "description": "Tires",
    "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
  }
]

Responses

Status Meaning Description Schema
200 OK Success StampingDevices

Updates chosen stamping device

Code samples

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

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

const inputBody = '{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/devices/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/devices/{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/stampings/devices/{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/stampings/devices/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

PUT /api/v1/stampings/devices/{id}

Updates chosen stamping device...

Body parameter

{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}

Parameters

Name In Type Required Description
id path string true stamping device id
body body StampingDevice false stamping device attributes

Example responses

401 Response

Responses

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

Renders a company stamping device by device id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_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/stampings/{company_id}/devices/by_device_id/{device_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_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/stampings/{company_id}/devices/by_device_id/{device_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/stampings/{company_id}/devices/by_device_id/{device_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{company_id}/devices/by_device_id/{device_id}

Renders a company stamping device by device id...

Parameters

Name In Type Required Description
company_id path string true company id
device_id path string true device id

Example responses

200 Response

{
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
  "name": "Leisure Goods",
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "enabled": false,
  "device_type": "nfc",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "description": "Tires",
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
}

Responses

Status Meaning Description Schema
200 OK Success StampingDevice

Renders a beacon

Code samples

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

GET https://api.fluida.io/api/v1/stampings/beacons/{eid} 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/stampings/beacons/{eid}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/beacons/{eid}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/beacons/{eid}', 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/stampings/beacons/{eid}', 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/stampings/beacons/{eid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/beacons/{eid}

Renders a beacon...

Parameters

Name In Type Required Description
eid path string true eid

Example responses

200 Response

{
  "name": "string",
  "description": "string",
  "beacon_id": "string"
}

Responses

Status Meaning Description Schema
200 OK Success BeaconId

Updates chosen stamping area contracts

Code samples

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

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

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

fetch('https://api.fluida.io/api/v1/stampings/areas/{id}/contracts',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/areas/{id}/contracts', 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/stampings/areas/{id}/contracts', 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/stampings/areas/{id}/contracts");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates chosen stamping area contracts...

Body parameter

{
  "contract_ids": [
    "string"
  ]
}

Parameters

Name In Type Required Description
id path string true stamping area id
body body StampingAreaContracts false stamping area attributes

Example responses

401 Response

Responses

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

Renders a list of contract devices for a given contract id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices 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/stampings/contracts/{contract_id}/devices',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices', 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/stampings/contracts/{contract_id}/devices', 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/stampings/contracts/{contract_id}/devices");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/contracts/{contract_id}/devices

Renders a list of contract devices for a given contract id...

Parameters

Name In Type Required Description
contract_id path string true contract id

Example responses

200 Response

[
  {
    "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
    "name": "Fixed Line Telecommunications",
    "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
    "enabled": false,
    "device_info": {},
    "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
    "description": "Hotel & Lodging REITs",
    "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
    "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
  }
]

Responses

Status Meaning Description Schema
200 OK Success ContractDevices

Rejects stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string HTTP/1.1
Host: api.fluida.io
Accept: */*


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

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string',
{
  method: 'PUT',

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

require 'rest-client'
require 'json'

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

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}',
  params: {
  'closer_id' => 'string'
}, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}', params={
  'closer_id': 'string'
}, headers = headers)

print(r.json())

<?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/stampings/{contract_id}/reject/{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/stampings/{contract_id}/reject/{id}?closer_id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

PUT /api/v1/stampings/{contract_id}/reject/{id}

Rejects stamping for a contract...

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true stamping id
closer_id query string true rejector id
rejector_notes query string false rejector notes

Example responses

401 Response

Responses

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

Renders a company contract device

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_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/stampings/{company_id}/contracts/devices/by_id/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_id/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_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/stampings/{company_id}/contracts/devices/by_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/stampings/{company_id}/contracts/devices/by_id/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{company_id}/contracts/devices/by_id/{id}

Renders a company contract device...

Parameters

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

Example responses

200 Response

{
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
  "name": "Fixed Line Telecommunications",
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "enabled": false,
  "device_info": {},
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "description": "Hotel & Lodging REITs",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
}

Responses

Status Meaning Description Schema
200 OK Success ContractDevice

Renders a list of stampings to be approved by a given contract id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json


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

fetch('https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}', 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/stampings/to_be_approved/{approver_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/stampings/to_be_approved/{approver_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/to_be_approved/{approver_id}

Renders a list of stampings to be approved by a given contract id...

Parameters

Name In Type Required Description
approver_id path string true approver id
limit query string false limit

Example responses

200 Response

[
  {
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
    "team_ids": [],
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "status": "recorded",
    "server_clock_at": "2023-11-27T13:24:27.090296Z",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "direction": "IN",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "clock_tz": "Etc/UTC",
    "clock_type": "clock",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_at": "2023-11-27T13:24:27.090293Z",
    "change_log": [],
    "badge_id": "8283876937",
    "approver_ids": []
  }
]

Responses

Status Meaning Description Schema
200 OK Success Stampings

Renders eid params

Code samples

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

GET https://api.fluida.io/api/v1/stampings/beacons/eid/params HTTP/1.1
Host: api.fluida.io
Accept: application/json


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

fetch('https://api.fluida.io/api/v1/stampings/beacons/eid/params',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/beacons/eid/params',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/beacons/eid/params', 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/stampings/beacons/eid/params', 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/stampings/beacons/eid/params");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/beacons/eid/params

Renders eid params...

Example responses

200 Response

{
  "public_key": "string",
  "min_exponent": "string",
  "max_exponent": "string"
}

Responses

Status Meaning Description Schema
200 OK Success EidParams

Renders a company stamping area

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{company_id}/areas/by_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/stampings/{company_id}/areas/by_id/{id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/areas/by_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/stampings/{company_id}/areas/by_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/stampings/{company_id}/areas/by_id/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{company_id}/areas/by_id/{id}

Renders a company stamping area...

Parameters

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

Example responses

200 Response

{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}

Responses

Status Meaning Description Schema
200 OK Success StampingArea

Updates chosen contract device

Code samples

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

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

const inputBody = '{
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
  "name": "Fixed Line Telecommunications",
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "enabled": false,
  "device_info": {},
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "description": "Hotel & Lodging REITs",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/contracts/devices/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/contracts/devices/{id}', 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/stampings/contracts/devices/{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/stampings/contracts/devices/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates chosen contract device...

Body parameter

{
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438",
  "name": "Fixed Line Telecommunications",
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "enabled": false,
  "device_info": {},
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "description": "Hotel & Lodging REITs",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669"
}

Parameters

Name In Type Required Description
id path string true contract device id
body body ContractDevice false contract device attributes

Example responses

401 Response

Responses

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

Renders a denormalized list of timestams

Code samples

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

GET https://api.fluida.io/api/v1/stampings/list/{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/stampings/list/{company_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/list/{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/stampings/list/{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/stampings/list/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/list/{company_id}

Renders a list of timestamps for a given company id with details about user and workplace

Parameters

Name In Type Required Description
company_id path string true company id
contract_id query string false Contract UUID
clock_id query string false Clocking Device UUID
subsidiary_id query string false Workplace UUID
statuses query array[string] false Statuses
clock_type query string false Statuses
from_date query string false From Date
to_date query string false To Date

Example responses

200 Response

[
  {
    "user_lastname": "Bar",
    "user_firstname": "Foo",
    "user_email": "foo@bar.com",
    "updated_at": "2023-11-27T13:24:27.090636Z",
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "subsdiriary_name": "Some Workplace",
    "status": "recorded",
    "server_clock_at": "2023-11-27T13:24:27.090631Z",
    "register_id": "AAA1234-2",
    "inserted_at": "2023-11-27T13:24:27.090634Z",
    "id": "9297ea46-3362-434d-8efd-4c9ba826da65",
    "direction": "IN",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "clock_tz": "Etc/UTC",
    "clock_type": "clock",
    "clock_name": "Some Clocking Device",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "badge_id": "8283876937"
  }
]

Responses

Status Meaning Description Schema
200 OK Success DenormalizedStampings

Adds notes to chosen stamping

Code samples

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

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

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

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/stamping/{id}/add_notes',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/stamping/{id}/add_notes', 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/stampings/{contract_id}/stamping/{id}/add_notes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

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

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

PUT /api/v1/stampings/{contract_id}/stamping/{id}/add_notes

Adds notes to chosen stamping

Body parameter

{
  "updated_by": "string",
  "notes": "string"
}

Parameters

Name In Type Required Description
contract_id path string true stamping id
id path string true stamping id
body body StampingNotes false stamping attributes

Example responses

401 Response

Responses

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

Updates chosen stamping area

Code samples

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

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

const inputBody = '{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/areas/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/areas/{id}', 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/stampings/areas/{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/stampings/areas/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates chosen stamping area...

Body parameter

{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}

Parameters

Name In Type Required Description
id path string true stamping area id
body body StampingArea false stamping area attributes

Example responses

401 Response

Responses

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

Renders a list of stamping devices for a given company id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/devices/by_company/{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/stampings/devices/by_company/{company_id}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/devices/by_company/{company_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/devices/by_company/{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/stampings/devices/by_company/{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/stampings/devices/by_company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/devices/by_company/{company_id}

Renders a list of stamping devices for a given company id...

Parameters

Name In Type Required Description
company_id path string true company id

Example responses

200 Response

[
  {
    "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e",
    "name": "Leisure Goods",
    "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
    "enabled": false,
    "device_type": "nfc",
    "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
    "description": "Tires",
    "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826"
  }
]

Responses

Status Meaning Description Schema
200 OK Success StampingDevices

Records a user stamping clock

Code samples

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

POST https://api.fluida.io/api/v1/stampings/{contract_id}/clock HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

const inputBody = '{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "sign": "signature",
  "server_clock_at": "2023-11-27T13:24:27.090240Z",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2023-11-27T13:24:27.090236Z",
  "badge_id": "8283876937",
  "approver_ids": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/{contract_id}/clock', 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/stampings/{contract_id}/clock', 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/stampings/{contract_id}/clock");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/stampings/{contract_id}/clock

Records a user stamping clock...

Body parameter

{
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de",
  "team_ids": [],
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "sign": "signature",
  "server_clock_at": "2023-11-27T13:24:27.090240Z",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "clock_tz": "Etc/UTC",
  "clock_type": "clock",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_at": "2023-11-27T13:24:27.090236Z",
  "badge_id": "8283876937",
  "approver_ids": []
}

Parameters

Name In Type Required Description
contract_id path string true contract id
body body StampingRequest false stamping attributes

Example responses

401 Response

Responses

Status Meaning Description Schema
200 OK Ok None
401 Unauthorized Unauthorized Unauthorized

Deletes a contract device for a company

Code samples

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

DELETE https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*


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

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{id}',
{
  method: 'DELETE',

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{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/stampings/{company_id}/contracts/devices/{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/stampings/{company_id}/contracts/devices/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

DELETE /api/v1/stampings/{company_id}/contracts/devices/{id}

Deletes a contract device for a company

Parameters

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

Example responses

401 Response

Responses

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

Create stamping area

Code samples

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

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

const inputBody = '{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/areas',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/areas', 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/stampings/areas', 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/stampings/areas");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/stampings/areas

Create stamping area...

Body parameter

{
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
  "radius": "50",
  "name": "Life Insurance",
  "long": "69.22462284381567",
  "lat": "17.57140909572334",
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "enabled": false,
  "detached": false,
  "description": "Health Care Providers",
  "contracts": [],
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "additional_details": {}
}

Parameters

Name In Type Required Description
body body StampingArea false stamping area attributes

Example responses

401 Response

Responses

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

Renders a company stamping device by eid

Code samples

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

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid} 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/stampings/{company_id}/devices/by_eid/{eid}',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid}',
  params: {
  }, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid}', 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/stampings/{company_id}/devices/by_eid/{eid}', 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/stampings/{company_id}/devices/by_eid/{eid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/{company_id}/devices/by_eid/{eid}

Renders a company stamping device by eid...

Parameters

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

Example responses

200 Response

{
  "stamping_device": null,
  "beacon": null
}

Responses

Status Meaning Description Schema
200 OK Success BeaconDevice

Renders a list of stamping areas for a given contract id

Code samples

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

GET https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}?company_id=string 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/stampings/areas/by_contract/{contract_id}?company_id=string',
{
  method: 'GET',

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

require 'rest-client'
require 'json'

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

result = RestClient.get 'https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}',
  params: {
  'company_id' => 'string'
}, headers: headers

p JSON.parse(result)

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

r = requests.get('https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}', params={
  'company_id': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

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

$client = new \GuzzleHttp\Client();

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

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/stampings/areas/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/stampings/areas/by_contract/{contract_id}?company_id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /api/v1/stampings/areas/by_contract/{contract_id}

Renders a list of stamping areas for a given contract id...

Parameters

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

Example responses

200 Response

[
  {
    "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1",
    "radius": "50",
    "name": "Life Insurance",
    "long": "69.22462284381567",
    "lat": "17.57140909572334",
    "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
    "enabled": false,
    "detached": false,
    "description": "Health Care Providers",
    "contracts": [],
    "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
    "additional_details": {}
  }
]

Responses

Status Meaning Description Schema
200 OK Success StampingAreas

Registers a beacon

Code samples

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

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

const inputBody = '{
  "resolver_public_key": "string",
  "initial_eid": "string",
  "initial_clock": "string",
  "exponent": "string",
  "description": "string",
  "beacon_public_key": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/beacons',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.post('https://api.fluida.io/api/v1/stampings/beacons', 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/stampings/beacons', 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/stampings/beacons");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/stampings/beacons

Registers a beacon...

Body parameter

{
  "resolver_public_key": "string",
  "initial_eid": "string",
  "initial_clock": "string",
  "exponent": "string",
  "description": "string",
  "beacon_public_key": "string"
}

Parameters

Name In Type Required Description
body body Beacon false beacon attributes

Example responses

401 Response

Responses

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

Approves stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string HTTP/1.1
Host: api.fluida.io
Accept: */*


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

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string',
{
  method: 'PUT',

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

require 'rest-client'
require 'json'

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

result = RestClient.put 'https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}',
  params: {
  'closer_id' => 'string'
}, headers: headers

p JSON.parse(result)

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

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}', params={
  'closer_id': 'string'
}, headers = headers)

print(r.json())

<?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/stampings/{contract_id}/approve/{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/stampings/{contract_id}/approve/{id}?closer_id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

PUT /api/v1/stampings/{contract_id}/approve/{id}

Approves stamping for a contract...

Parameters

Name In Type Required Description
contract_id path string true contract id
id path string true stamping id
closer_id query string true approver id
approver_notes query string false approver notes

Example responses

401 Response

Responses

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

Deletes a stamping device for a company

Code samples

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

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


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

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

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

require 'rest-client'
require 'json'

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

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

p JSON.parse(result)

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

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/devices/{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/stampings/{company_id}/devices/{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/stampings/{company_id}/devices/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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