NAV Navigation
JavaScript Http Python Java Go

Byteline APIs v1

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

API documentation of Byteline services.

Base URLs:

Terms of service Email: Byteline Web: Byteline License: Commercial

Authentication

billing-controller

Billing Controller

getUserPlan

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/billing/plan',
{
  method: 'GET',

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

GET /api.byteline.io/billing/plan HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/billing/plan', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/billing/plan");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/billing/plan", data)
    req.Header = headers

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

GET /billing/plan

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

changePlan

Code samples


fetch('/api.byteline.io/billing/plan/{billingPlan}',
{
  method: 'POST'

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

POST /api.byteline.io/billing/plan/{billingPlan} HTTP/1.1

import requests

r = requests.post('/api.byteline.io/billing/plan/{billingPlan}')

print(r.json())

URL obj = new URL("/api.byteline.io/billing/plan/{billingPlan}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/billing/plan/{billingPlan}", data)
    req.Header = headers

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

POST /billing/plan/{billingPlan}

Parameters

Name In Type Required Description
billingPlan path string true billingPlan

Enumerated Values

Parameter Value
billingPlan Free
billingPlan Basic
billingPlan Standard
billingPlan Growth
billingPlan Pro
billingPlan Business

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

createSession

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/billing/session/{billingPlan}',
{
  method: 'POST',

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

POST /api.byteline.io/billing/session/{billingPlan} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.post('/api.byteline.io/billing/session/{billingPlan}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/billing/session/{billingPlan}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/billing/session/{billingPlan}", data)
    req.Header = headers

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

POST /billing/session/{billingPlan}

Parameters

Name In Type Required Description
billingPlan path string true billingPlan

Enumerated Values

Parameter Value
billingPlan Free
billingPlan Basic
billingPlan Standard
billingPlan Growth
billingPlan Pro
billingPlan Business

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

stripeWebhook

Code samples

const inputBody = 'string';
const headers = {
  'Content-Type':'application/json',
  'Stripe-Signature':'string'
};

fetch('/api.byteline.io/billing/stripe/webhooks',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/billing/stripe/webhooks HTTP/1.1

Content-Type: application/json

Stripe-Signature: string

import requests
headers = {
  'Content-Type': 'application/json',
  'Stripe-Signature': 'string'
}

r = requests.post('/api.byteline.io/billing/stripe/webhooks', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/billing/stripe/webhooks");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Stripe-Signature": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/billing/stripe/webhooks", data)
    req.Header = headers

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

POST /billing/stripe/webhooks

Body parameter

"string"

Parameters

Name In Type Required Description
Stripe-Signature header string true Stripe-Signature
body body string true payload

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

connection-controller

Connection Controller

getAuthTokens

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/connection',
{
  method: 'GET',

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

GET /api.byteline.io/connection HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/connection', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/connection");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/connection", data)
    req.Header = headers

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

GET /connection

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [AuthTokenResponseDto] false none none
» AuthTokenResponseDto AuthTokenResponseDto false none none
»» apiKey string false none none
»» issuer string false none none
»» scope string false none none
»» type string false none none

addConnection

Code samples

const inputBody = '{
  "accessToken": "string",
  "accessTokenExpiry": "2021-09-20T17:39:01Z",
  "apiKey": "string",
  "issuer": "string",
  "refreshToken": "string",
  "scope": "string",
  "type": "string",
  "userInfo": {}
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/connection',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/connection HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/connection', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/connection");
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"},
    }

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

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

POST /connection

Body parameter

{
  "accessToken": "string",
  "accessTokenExpiry": "2021-09-20T17:39:01Z",
  "apiKey": "string",
  "issuer": "string",
  "refreshToken": "string",
  "scope": "string",
  "type": "string",
  "userInfo": {}
}

Parameters

Name In Type Required Description
body body AuthToken true authToken

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getIssuers

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/connection/issuers',
{
  method: 'GET',

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

GET /api.byteline.io/connection/issuers HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/connection/issuers', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/connection/issuers");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/connection/issuers", data)
    req.Header = headers

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

GET /connection/issuers

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [AuthIssuerItem] false none none
» AuthIssuerItem AuthIssuerItem false none none
»» displayName string false none none
»» issuer string false none none
»» type string false none none

deleteConnection

Code samples


fetch('/api.byteline.io/connection/{issuer}',
{
  method: 'DELETE'

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

DELETE /api.byteline.io/connection/{issuer} HTTP/1.1

import requests

r = requests.delete('/api.byteline.io/connection/{issuer}')

print(r.json())

URL obj = new URL("/api.byteline.io/connection/{issuer}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api.byteline.io/connection/{issuer}", data)
    req.Header = headers

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

DELETE /connection/{issuer}

Parameters

Name In Type Required Description
issuer path string true issuer

Responses

Status Meaning Description Schema
200 OK OK None
204 No Content No Content None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None

getIssuerRequiredProps

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/connection/{issuer}/props',
{
  method: 'GET',

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

GET /api.byteline.io/connection/{issuer}/props HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/connection/{issuer}/props', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/connection/{issuer}/props");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/connection/{issuer}/props", data)
    req.Header = headers

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

GET /connection/{issuer}/props

Parameters

Name In Type Required Description
issuer path string true issuer

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

demo-flow-controller

Demo Flow Controller

Execute flow with the given ID

Code samples


const headers = {
  'Authorization':'API_KEY'
};

fetch('/api.byteline.io/flow/f1256a3fc-49fc-42ff-bf18-60b01cc73981',
{
  method: 'POST',

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

POST /api.byteline.io/flow/f1256a3fc-49fc-42ff-bf18-60b01cc73981 HTTP/1.1

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.post('/api.byteline.io/flow/f1256a3fc-49fc-42ff-bf18-60b01cc73981', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/f1256a3fc-49fc-42ff-bf18-60b01cc73981");
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{
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/f1256a3fc-49fc-42ff-bf18-60b01cc73981", data)
    req.Header = headers

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

POST /flow/f1256a3fc-49fc-42ff-bf18-60b01cc73981

Execute flow with the ID provided in the URL

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

flow-action-group-controller

Flow Action Group Controller

addActionGroup

Code samples

const inputBody = '{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/action-group',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/action-group HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/flow/action-group', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/action-group", data)
    req.Header = headers

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

POST /flow/action-group

Body parameter

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

Parameters

Name In Type Required Description
body body NodeTypeRequest true actionGroupRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getAllActionGroups

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/action-group/all',
{
  method: 'GET',

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

GET /api.byteline.io/flow/action-group/all HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/action-group/all', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/all");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/action-group/all", data)
    req.Header = headers

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

GET /flow/action-group/all

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [ActionGroupResponse] false none none
» ActionGroupResponse ActionGroupResponse false none none
»» displayName string false none none
»» name string false none none

getAllActionGroupFlows

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}',
{
  method: 'GET',

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

GET /api.byteline.io/flow/action-group/{actionGroup} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/action-group/{actionGroup}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/action-group/{actionGroup}", data)
    req.Header = headers

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

GET /flow/action-group/{actionGroup}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties [SimpleFlowDto] false none none
»» SimpleFlowDto SimpleFlowDto false none none
»»» flowId string false none none
»»» flowName string false none none

addFlowToActionGroup

Code samples

const inputBody = '{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/action-group/{actionGroup} HTTP/1.1

Content-Type: application/json
Accept: */*

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

r = requests.post('/api.byteline.io/flow/action-group/{actionGroup}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/action-group/{actionGroup}", data)
    req.Header = headers

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

POST /flow/action-group/{actionGroup}

Body parameter

{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
body body CreateFlowRequest true createFlowRequest

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

updateActionGroup

Code samples

const inputBody = '{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/flow/action-group/{actionGroup} HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/flow/action-group/{actionGroup}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/flow/action-group/{actionGroup}", data)
    req.Header = headers

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

PUT /flow/action-group/{actionGroup}

Body parameter

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
body body NodeTypeRequest true actionGroupRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

addActionGroupNode

Code samples

const inputBody = '{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}/node',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/action-group/{actionGroup}/node HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/flow/action-group/{actionGroup}/node', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}/node");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/action-group/{actionGroup}/node", data)
    req.Header = headers

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

POST /flow/action-group/{actionGroup}/node

Body parameter

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
body body NodeTypeRequest true actionGroupRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getActionGroupNode

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}',
{
  method: 'GET',

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

GET /api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}", data)
    req.Header = headers

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

GET /flow/action-group/{actionGroup}/node/{nodeType}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
nodeType path string true nodeType

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK NodeTypeResponse
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

updateActionGroupNode

Code samples

const inputBody = '{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType} HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/flow/action-group/{actionGroup}/node/{nodeType}", data)
    req.Header = headers

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

PUT /flow/action-group/{actionGroup}/node/{nodeType}

Body parameter

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
nodeType path string true nodeType
body body NodeTypeRequest true actionGroupRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getFlow

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}/{flowId}',
{
  method: 'GET',

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

GET /api.byteline.io/flow/action-group/{actionGroup}/{flowId} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/action-group/{actionGroup}/{flowId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}/{flowId}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/action-group/{actionGroup}/{flowId}", data)
    req.Header = headers

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

GET /flow/action-group/{actionGroup}/{flowId}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK FlowDto
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

updateFlow

Code samples

const inputBody = '{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/action-group/{actionGroup}/{flowId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/flow/action-group/{actionGroup}/{flowId} HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/flow/action-group/{actionGroup}/{flowId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}/{flowId}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/flow/action-group/{actionGroup}/{flowId}", data)
    req.Header = headers

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

PUT /flow/action-group/{actionGroup}/{flowId}

Body parameter

{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
flowId path string true flowId
body body CreateFlowRequest true createFlowRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

deployFlow

Code samples


fetch('/api.byteline.io/flow/action-group/{actionGroup}/{flowId}/deploy',
{
  method: 'POST'

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

POST /api.byteline.io/flow/action-group/{actionGroup}/{flowId}/deploy HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow/action-group/{actionGroup}/{flowId}/deploy')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/action-group/{actionGroup}/{flowId}/deploy");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/action-group/{actionGroup}/{flowId}/deploy", data)
    req.Header = headers

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

POST /flow/action-group/{actionGroup}/{flowId}/deploy

Parameters

Name In Type Required Description
actionGroup path string true actionGroup
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

flow-controller

Flow Controller

addFlow

Code samples

const inputBody = '{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow HTTP/1.1

Content-Type: application/json
Accept: */*

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

r = requests.post('/api.byteline.io/flow', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow");
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{"*/*"},
    }

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

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

POST /flow

Body parameter

{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}

Parameters

Name In Type Required Description
body body CreateFlowRequest true createFlowRequest

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

getAllUserFlows

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/all',
{
  method: 'GET',

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

GET /api.byteline.io/flow/all HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/all', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/all");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/all", data)
    req.Header = headers

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

GET /flow/all

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

getAllPublicFlows

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/all/public',
{
  method: 'GET',

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

GET /api.byteline.io/flow/all/public HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/all/public', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/all/public");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/all/public", data)
    req.Header = headers

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

GET /flow/all/public

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [FlowDto] false none none
» FlowDto FlowDto false none none
»» config object false none none
»»» ObjectNode ObjectNode false none none
»»»» array boolean false none none
»»»» bigDecimal boolean false none none
»»»» bigInteger boolean false none none
»»»» binary boolean false none none
»»»» boolean boolean false none none
»»»» containerNode boolean false none none
»»»» double boolean false none none
»»»» empty boolean false none none
»»»» float boolean false none none
»»»» floatingPointNumber boolean false none none
»»»» int boolean false none none
»»»» integralNumber boolean false none none
»»»» long boolean false none none
»»»» missingNode boolean false none none
»»»» nodeType string false none none
»»»» null boolean false none none
»»»» number boolean false none none
»»»» object boolean false none none
»»»» pojo boolean false none none
»»»» short boolean false none none
»»»» textual boolean false none none
»»»» valueNode boolean false none none
»» deployStatus string false none none
»» flowId string false none none
»» flowImageUrl string false none none
»» flowName string false none none
»» pastNodeSuccessStatus object false none none
»»» additionalProperties boolean false none none
»» publicAccess boolean false none none
»» publicDescription string false none none
»» uiFlow UiFlow false none none
»»» edges [UiEdge] false none none
»»»» UiEdge UiEdge false none none
»»»»» data ObjectNode false none none
»»»»» source string false none none
»»»»» target string false none none
»»» groups ArrayNode false none none
»»»» array boolean false none none
»»»» bigDecimal boolean false none none
»»»» bigInteger boolean false none none
»»»» binary boolean false none none
»»»» boolean boolean false none none
»»»» containerNode boolean false none none
»»»» double boolean false none none
»»»» empty boolean false none none
»»»» float boolean false none none
»»»» floatingPointNumber boolean false none none
»»»» int boolean false none none
»»»» integralNumber boolean false none none
»»»» long boolean false none none
»»»» missingNode boolean false none none
»»»» nodeType string false none none
»»»» null boolean false none none
»»»» number boolean false none none
»»»» object boolean false none none
»»»» pojo boolean false none none
»»»» short boolean false none none
»»»» textual boolean false none none
»»»» valueNode boolean false none none
»»» nodes [UiNode] false none none
»»»» UiNode UiNode false none none
»»»»» h integer(int32) false none none
»»»»» id string false none none
»»»»» left integer(int32) false none none
»»»»» nodeType string false none none
»»»»» top integer(int32) false none none
»»»»» type string false none none
»»»»» w integer(int32) false none none
»»» ports ArrayNode false none none

Enumerated Values

Property Value
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING
deployStatus Deployed
deployStatus Need_Redeploy
deployStatus Not_Deployed
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING

getUserFlow

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}',
{
  method: 'GET',

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

GET /api.byteline.io/flow/{flowId} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/{flowId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/{flowId}", data)
    req.Header = headers

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

GET /flow/{flowId}

Parameters

Name In Type Required Description
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK FlowDto
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

updateFlow

Code samples

const inputBody = '{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/{flowId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/flow/{flowId} HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/flow/{flowId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/flow/{flowId}", data)
    req.Header = headers

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

PUT /flow/{flowId}

Body parameter

{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}

Parameters

Name In Type Required Description
flowId path string true flowId
body body CreateFlowRequest true createFlowRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

deleteFlow

Code samples


fetch('/api.byteline.io/flow/{flowId}',
{
  method: 'DELETE'

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

DELETE /api.byteline.io/flow/{flowId} HTTP/1.1

import requests

r = requests.delete('/api.byteline.io/flow/{flowId}')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api.byteline.io/flow/{flowId}", data)
    req.Header = headers

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

DELETE /flow/{flowId}

Parameters

Name In Type Required Description
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
204 No Content No Content None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None

getAirtableTriggerData

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/at-trigger',
{
  method: 'GET',

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

GET /api.byteline.io/flow/{flowId}/at-trigger HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/{flowId}/at-trigger', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/at-trigger");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/{flowId}/at-trigger", data)
    req.Header = headers

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

GET /flow/{flowId}/at-trigger

Parameters

Name In Type Required Description
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK AirtableTriggerDto
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

cancelDetermineInputStructure

Code samples


fetch('/api.byteline.io/flow/{flowId}/cancel-determine-input-structure',
{
  method: 'POST'

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

POST /api.byteline.io/flow/{flowId}/cancel-determine-input-structure HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow/{flowId}/cancel-determine-input-structure')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/cancel-determine-input-structure");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/cancel-determine-input-structure", data)
    req.Header = headers

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

POST /flow/{flowId}/cancel-determine-input-structure

Parameters

Name In Type Required Description
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

captureInputStructure

Code samples

const inputBody = '{}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/{flowId}/capture',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/{flowId}/capture HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/flow/{flowId}/capture', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/capture");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/capture", data)
    req.Header = headers

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

POST /flow/{flowId}/capture

Body parameter

{}

Parameters

Name In Type Required Description
flowId path string true flowId
body body object true inputMap

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

cloneFlow

Code samples

const inputBody = '{
  "property1": "string",
  "property2": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/clone',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/{flowId}/clone HTTP/1.1

Content-Type: application/json
Accept: */*

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

r = requests.post('/api.byteline.io/flow/{flowId}/clone', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/clone");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/clone", data)
    req.Header = headers

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

POST /flow/{flowId}/clone

Body parameter

{
  "property1": "string",
  "property2": "string"
}

Parameters

Name In Type Required Description
flowId path string true flowId
body body object true inputMap
» additionalProperties body string false none

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

deployFlow

Code samples


fetch('/api.byteline.io/flow/{flowId}/deploy',
{
  method: 'POST'

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

POST /api.byteline.io/flow/{flowId}/deploy HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow/{flowId}/deploy')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/deploy");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/deploy", data)
    req.Header = headers

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

POST /flow/{flowId}/deploy

Parameters

Name In Type Required Description
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getInputStructureStatus

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/determine-input-structure',
{
  method: 'GET',

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

GET /api.byteline.io/flow/{flowId}/determine-input-structure HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/{flowId}/determine-input-structure', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/determine-input-structure");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/{flowId}/determine-input-structure", data)
    req.Header = headers

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

GET /flow/{flowId}/determine-input-structure

Parameters

Name In Type Required Description
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

determineInputStructure

Code samples


fetch('/api.byteline.io/flow/{flowId}/determine-input-structure',
{
  method: 'POST'

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

POST /api.byteline.io/flow/{flowId}/determine-input-structure HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow/{flowId}/determine-input-structure')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/determine-input-structure");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/determine-input-structure", data)
    req.Header = headers

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

POST /flow/{flowId}/determine-input-structure

Parameters

Name In Type Required Description
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

updateFlowImage

Code samples

const inputBody = '{
  "data": "string",
  "extension": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/flow/{flowId}/image',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/flow/{flowId}/image HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/flow/{flowId}/image', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/image");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/flow/{flowId}/image", data)
    req.Header = headers

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

PUT /flow/{flowId}/image

Body parameter

{
  "data": "string",
  "extension": "string"
}

Parameters

Name In Type Required Description
flowId path string true flowId
body body UploadFlowImageDto true uploadFlowImageDto

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getPublicUserFlow

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/public',
{
  method: 'GET',

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

GET /api.byteline.io/flow/{flowId}/public HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/{flowId}/public', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/public");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/{flowId}/public", data)
    req.Header = headers

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

GET /flow/{flowId}/public

Parameters

Name In Type Required Description
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK FlowDto
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

resumeFlow

Code samples


fetch('/api.byteline.io/flow/{flowId}/resume',
{
  method: 'POST'

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

POST /api.byteline.io/flow/{flowId}/resume HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow/{flowId}/resume')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/resume");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/resume", data)
    req.Header = headers

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

POST /flow/{flowId}/resume

Parameters

Name In Type Required Description
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

runFlowWithGet

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/run?queryParams=string',
{
  method: 'GET',

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

GET /api.byteline.io/flow/{flowId}/run?queryParams=string HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/{flowId}/run', params={
  'queryParams': 'string'
}, headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/run?queryParams=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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/{flowId}/run", data)
    req.Header = headers

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

GET /flow/{flowId}/run

Parameters

Name In Type Required Description
flowId path string true flowId
queryParams query string true queryParams

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties object false none none

runFlowWithPost

Code samples

const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/run',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/{flowId}/run HTTP/1.1

Content-Type: application/json
Accept: */*

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

r = requests.post('/api.byteline.io/flow/{flowId}/run', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/run");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/run", data)
    req.Header = headers

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

POST /flow/{flowId}/run

Body parameter

{}

Parameters

Name In Type Required Description
async query boolean false async
flowId path string true flowId
no-redirect query boolean false no-redirect
testrun query boolean false testrun
timeout query integer(int64) false timeout
body body object true inputMap

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties object false none none

stopFlow

Code samples


fetch('/api.byteline.io/flow/{flowId}/stop',
{
  method: 'POST'

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

POST /api.byteline.io/flow/{flowId}/stop HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow/{flowId}/stop')

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/stop");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/{flowId}/stop", data)
    req.Header = headers

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

POST /flow/{flowId}/stop

Parameters

Name In Type Required Description
flowId path string true flowId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getUserFlowVars

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow/{flowId}/vars',
{
  method: 'GET',

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

GET /api.byteline.io/flow/{flowId}/vars HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow/{flowId}/vars', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/{flowId}/vars");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow/{flowId}/vars", data)
    req.Header = headers

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

GET /flow/{flowId}/vars

Parameters

Name In Type Required Description
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK ObjectNode
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

flow-instance-controller

Flow Instance Controller

getTaskDetails

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow-instance/flow-engine/task/{taskId}',
{
  method: 'GET',

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

GET /api.byteline.io/flow-instance/flow-engine/task/{taskId} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow-instance/flow-engine/task/{taskId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow-instance/flow-engine/task/{taskId}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow-instance/flow-engine/task/{taskId}", data)
    req.Header = headers

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

GET /flow-instance/flow-engine/task/{taskId}

Parameters

Name In Type Required Description
taskId path string true taskId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK ObjectNode
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getFlowEngineDetails

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow-instance/flow-engine/{flowInstanceId}',
{
  method: 'GET',

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

GET /api.byteline.io/flow-instance/flow-engine/{flowInstanceId} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow-instance/flow-engine/{flowInstanceId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow-instance/flow-engine/{flowInstanceId}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow-instance/flow-engine/{flowInstanceId}", data)
    req.Header = headers

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

GET /flow-instance/flow-engine/{flowInstanceId}

Parameters

Name In Type Required Description
flowInstanceId path string true flowInstanceId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK ObjectNode
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

fetchExternalizedData

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow-instance/task/{taskId}/externalized-input',
{
  method: 'GET',

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

GET /api.byteline.io/flow-instance/task/{taskId}/externalized-input HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow-instance/task/{taskId}/externalized-input', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow-instance/task/{taskId}/externalized-input");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow-instance/task/{taskId}/externalized-input", data)
    req.Header = headers

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

GET /flow-instance/task/{taskId}/externalized-input

Parameters

Name In Type Required Description
taskId path string true taskId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

getFlowInstances

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow-instance/{flowId}',
{
  method: 'GET',

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

GET /api.byteline.io/flow-instance/{flowId} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow-instance/{flowId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow-instance/{flowId}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow-instance/{flowId}", data)
    req.Header = headers

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

GET /flow-instance/{flowId}

Parameters

Name In Type Required Description
flowId path string true flowId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [FlowInstanceItem] false none none
» FlowInstanceItem FlowInstanceItem false none none
»» actionsConsumed integer(int32) false none none
»» entityType string false none none
»» flowDefId string false none none
»» flowInstanceId string false none none
»» input object false none none
»» output object false none none
»» startTime string(date-time) false none none
»» startedBy string false none none
»» status string false none none
»» taskResults object false none none
»»» TaskResultItem TaskResultItem false none none
»»»» actionGroupFlowInstanceId string false none none
»»»» output object false none none
»»»» reasonForIncompletion string false none none
»»»» status string false none none
»»»» terminated boolean false none none
»»»» timeTaken integer(int64) false none none
»»»» timeTakenFromFlowStart integer(int64) false none none
»» terminated boolean false none none
»» terminatedAt string(date-time) false none none

Enumerated Values

Property Value
status RUNNING
status COMPLETED
status FAILED
status SCHEDULED
status RUNNING
status COMPLETED
status FAILED
status SCHEDULED

getFlowInstanceData

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/latest',
{
  method: 'GET',

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

GET /api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/latest HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/latest', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/latest");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/latest", data)
    req.Header = headers

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

GET /flow-instance/{flowId}/{flowInstanceId}/latest

Parameters

Name In Type Required Description
flowId path string true flowId
flowInstanceId path string true flowInstanceId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK FlowInstanceItem
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

reportIssue

Code samples


fetch('/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/report',
{
  method: 'POST'

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

POST /api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/report HTTP/1.1

import requests

r = requests.post('/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/report')

print(r.json())

URL obj = new URL("/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/report");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow-instance/{flowId}/{flowInstanceId}/report", data)
    req.Header = headers

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

POST /flow-instance/{flowId}/{flowInstanceId}/report

Parameters

Name In Type Required Description
flowId path string true flowId
flowInstanceId path string true flowInstanceId

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

flow-sns-notification-controller

Flow Sns Notification Controller

flowStatusNotification

Code samples

const inputBody = 'string';
const headers = {
  'Content-Type':'*/*',
  'headers':'string'
};

fetch('/api.byteline.io/flow/notification',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/notification HTTP/1.1

Content-Type: */*

headers: string

import requests
headers = {
  'Content-Type': '*/*',
  'headers': 'string'
}

r = requests.post('/api.byteline.io/flow/notification', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/notification");
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{"*/*"},
        "headers": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/notification", data)
    req.Header = headers

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

POST /flow/notification

Body parameter

Parameters

Name In Type Required Description
headers header string true headers
body body string true notificationMsg

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

taskStatusNotification

Code samples

const inputBody = 'string';
const headers = {
  'Content-Type':'*/*',
  'headers':'string'
};

fetch('/api.byteline.io/flow/task/notification',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/flow/task/notification HTTP/1.1

Content-Type: */*

headers: string

import requests
headers = {
  'Content-Type': '*/*',
  'headers': 'string'
}

r = requests.post('/api.byteline.io/flow/task/notification', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/flow/task/notification");
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{"*/*"},
        "headers": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/flow/task/notification", data)
    req.Header = headers

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

POST /flow/task/notification

Body parameter

Parameters

Name In Type Required Description
headers header string true headers
body body string true notificationMsg

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

node-type-controller

Node Type Controller

addNodeType

Code samples

const inputBody = '{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/nodetype',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/nodetype HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/nodetype', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/nodetype");
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"},
    }

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

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

POST /nodetype

Body parameter

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

Parameters

Name In Type Required Description
body body NodeTypeRequest true nodeTypeRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getAllNodeTypes

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/nodetype/all',
{
  method: 'GET',

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

GET /api.byteline.io/nodetype/all HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/nodetype/all', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/nodetype/all");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/nodetype/all", data)
    req.Header = headers

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

GET /nodetype/all

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [NodeTypeResponse] false none none
» NodeTypeResponse NodeTypeResponse false none none
»» actionGroupFlowId string false none none
»» category string false none none
»» configRequired boolean false none none
»» displayName string false none none
»» flowEngineType string false none none
»» internal boolean false none none
»» link string false none none
»» logoSquareUri string false none none
»» logoUri string false none none
»» loopOverOptions [string] false none none
»» name string false none none
»» order integer(int32) false none none
»» outputTemplate JsonNode false none none
»»» array boolean false none none
»»» bigDecimal boolean false none none
»»» bigInteger boolean false none none
»»» binary boolean false none none
»»» boolean boolean false none none
»»» containerNode boolean false none none
»»» double boolean false none none
»»» empty boolean false none none
»»» float boolean false none none
»»» floatingPointNumber boolean false none none
»»» int boolean false none none
»»» integralNumber boolean false none none
»»» long boolean false none none
»»» missingNode boolean false none none
»»» nodeType string false none none
»»» null boolean false none none
»»» number boolean false none none
»»» object boolean false none none
»»» pojo boolean false none none
»»» short boolean false none none
»»» textual boolean false none none
»»» valueNode boolean false none none
»» purpose string false none none
»» statement string false none none
»» timeoutSecs integer(int64) false none none
»» ui ObjectNode false none none
»»» array boolean false none none
»»» bigDecimal boolean false none none
»»» bigInteger boolean false none none
»»» binary boolean false none none
»»» boolean boolean false none none
»»» containerNode boolean false none none
»»» double boolean false none none
»»» empty boolean false none none
»»» float boolean false none none
»»» floatingPointNumber boolean false none none
»»» int boolean false none none
»»» integralNumber boolean false none none
»»» long boolean false none none
»»» missingNode boolean false none none
»»» nodeType string false none none
»»» null boolean false none none
»»» number boolean false none none
»»» object boolean false none none
»»» pojo boolean false none none
»»» short boolean false none none
»»» textual boolean false none none
»»» valueNode boolean false none none

Enumerated Values

Property Value
category Built_In
category CRM
category Business_Intelligence
category Productivity
category Communication
category Marketing
category Database
category Financial
category Social
category Analytics
category Traveling
category CMS
flowEngineType SIMPLE
flowEngineType DECISION
flowEngineType LAMBDA
flowEngineType DO_WHILE
flowEngineType WAIT
flowEngineType BYTELINE
flowEngineType JSON_JQ_TRANSFORM
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING
purpose Action
purpose Trigger
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING

getNodeType

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/nodetype/{nodeType}',
{
  method: 'GET',

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

GET /api.byteline.io/nodetype/{nodeType} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/nodetype/{nodeType}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/nodetype/{nodeType}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/nodetype/{nodeType}", data)
    req.Header = headers

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

GET /nodetype/{nodeType}

Parameters

Name In Type Required Description
nodeType path string true nodeType

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK NodeTypeResponse
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

updateNodeType

Code samples

const inputBody = '{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/nodetype/{nodeType}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/nodetype/{nodeType} HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/nodetype/{nodeType}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/nodetype/{nodeType}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/nodetype/{nodeType}", data)
    req.Header = headers

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

PUT /nodetype/{nodeType}

Body parameter

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

Parameters

Name In Type Required Description
nodeType path string true nodeType
body body NodeTypeRequest true nodeTypeRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

scraper-controller

Scraper Controller

addScraper

Code samples

const inputBody = '{
  "attributes": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "loopOver": "string",
  "maxPageLimit": 0,
  "name": "string",
  "paginationXPath": "string",
  "url": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*'
};

fetch('/api.byteline.io/scraper',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/scraper HTTP/1.1

Content-Type: application/json
Accept: */*

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

r = requests.post('/api.byteline.io/scraper', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper");
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{"*/*"},
    }

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

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

POST /scraper

Body parameter

{
  "attributes": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "loopOver": "string",
  "maxPageLimit": 0,
  "name": "string",
  "paginationXPath": "string",
  "url": "string"
}

Parameters

Name In Type Required Description
body body CreateScraperRequest true createScraperRequest

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

getScrapersForUser

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/scraper/all',
{
  method: 'GET',

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

GET /api.byteline.io/scraper/all HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/scraper/all', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/all");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/scraper/all", data)
    req.Header = headers

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

GET /scraper/all

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [IdName] false none none
» IdName IdName false none none
»» id string false none none
»» name string false none none

getIterableXPaths

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/scraper/iterable-xpaths?url=string',
{
  method: 'GET',

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

GET /api.byteline.io/scraper/iterable-xpaths?url=string HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/scraper/iterable-xpaths', params={
  'url': 'string'
}, headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/iterable-xpaths?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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/scraper/iterable-xpaths", data)
    req.Header = headers

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

GET /scraper/iterable-xpaths

Parameters

Name In Type Required Description
url query string true url

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

addIterableXpaths

Code samples

const inputBody = '{
  "repeatingXPaths": [
    "string"
  ],
  "url": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/scraper/iterable-xpaths',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/scraper/iterable-xpaths HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/scraper/iterable-xpaths', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/iterable-xpaths");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/scraper/iterable-xpaths", data)
    req.Header = headers

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

POST /scraper/iterable-xpaths

Body parameter

{
  "repeatingXPaths": [
    "string"
  ],
  "url": "string"
}

Parameters

Name In Type Required Description
body body ScraperIterableXpathDto true scraperIterableXpathDto

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

canUrlScraped

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/scraper/url/allowed?url=string',
{
  method: 'POST',

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

POST /api.byteline.io/scraper/url/allowed?url=string HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.post('/api.byteline.io/scraper/url/allowed', params={
  'url': 'string'
}, headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/url/allowed?url=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/scraper/url/allowed", data)
    req.Header = headers

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

POST /scraper/url/allowed

Parameters

Name In Type Required Description
url query string true url

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK ScraperUrlCheck
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getScraper

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/scraper/{scraperId}',
{
  method: 'GET',

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

GET /api.byteline.io/scraper/{scraperId} HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/scraper/{scraperId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/{scraperId}");
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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/scraper/{scraperId}", data)
    req.Header = headers

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

GET /scraper/{scraperId}

Parameters

Name In Type Required Description
scraperId path string true scraperId

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK ScraperItem
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

updateScraper

Code samples

const inputBody = '{
  "attributes": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "loopOver": "string",
  "maxPageLimit": 0,
  "name": "string",
  "paginationXPath": "string",
  "url": "string"
}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/scraper/{scraperId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PUT /api.byteline.io/scraper/{scraperId} HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.put('/api.byteline.io/scraper/{scraperId}', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/{scraperId}");
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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/scraper/{scraperId}", data)
    req.Header = headers

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

PUT /scraper/{scraperId}

Body parameter

{
  "attributes": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "loopOver": "string",
  "maxPageLimit": 0,
  "name": "string",
  "paginationXPath": "string",
  "url": "string"
}

Parameters

Name In Type Required Description
scraperId path string true scraperId
body body CreateScraperRequest true createScraperRequest

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

deleteScraper

Code samples


fetch('/api.byteline.io/scraper/{scraperId}',
{
  method: 'DELETE'

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

DELETE /api.byteline.io/scraper/{scraperId} HTTP/1.1

import requests

r = requests.delete('/api.byteline.io/scraper/{scraperId}')

print(r.json())

URL obj = new URL("/api.byteline.io/scraper/{scraperId}");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api.byteline.io/scraper/{scraperId}", data)
    req.Header = headers

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

DELETE /scraper/{scraperId}

Parameters

Name In Type Required Description
scraperId path string true scraperId

Responses

Status Meaning Description Schema
200 OK OK None
204 No Content No Content None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None

temp-controller

Temp Controller

getAirtableSchema

Code samples


const headers = {
  'Accept':'*/*'
};

fetch('/api.byteline.io/tmp/airtable/meta?base=string&table=string',
{
  method: 'GET',

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

GET /api.byteline.io/tmp/airtable/meta?base=string&table=string HTTP/1.1

Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('/api.byteline.io/tmp/airtable/meta', params={
  'base': 'string',  'table': 'string'
}, headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/tmp/airtable/meta?base=string&table=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{"*/*"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/api.byteline.io/tmp/airtable/meta", data)
    req.Header = headers

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

GET /tmp/airtable/meta

Parameters

Name In Type Required Description
base query string true base
table query string true table

Example responses

200 Response

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Map_string_string_] false none none
» Map«string,string» Map_string_string_ false none none
»» additionalProperties string false none none

user-controller

User Controller

deleteUser

Code samples


fetch('/api.byteline.io/user',
{
  method: 'DELETE'

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

DELETE /api.byteline.io/user HTTP/1.1

import requests

r = requests.delete('/api.byteline.io/user')

print(r.json())

URL obj = new URL("/api.byteline.io/user");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/api.byteline.io/user", data)
    req.Header = headers

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

DELETE /user

Responses

Status Meaning Description Schema
200 OK OK None
204 No Content No Content None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None

getApiKey

Code samples


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

fetch('/api.byteline.io/user/api-key',
{
  method: 'GET',

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

GET /api.byteline.io/user/api-key HTTP/1.1

Accept: application/json

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

r = requests.get('/api.byteline.io/user/api-key', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/api-key");
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", "/api.byteline.io/user/api-key", data)
    req.Header = headers

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

GET /user/api-key

Example responses

200 Response

{
  "property1": "string",
  "property2": "string"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

regenerateApiKey

Code samples


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

fetch('/api.byteline.io/user/api-key',
{
  method: 'POST',

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

POST /api.byteline.io/user/api-key HTTP/1.1

Accept: application/json

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

r = requests.post('/api.byteline.io/user/api-key', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/api-key");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/user/api-key", data)
    req.Header = headers

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

POST /user/api-key

Example responses

200 Response

{
  "property1": "string",
  "property2": "string"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

createCannyToken

Code samples


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

fetch('/api.byteline.io/user/canny-token',
{
  method: 'GET',

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

GET /api.byteline.io/user/canny-token HTTP/1.1

Accept: application/json

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

r = requests.get('/api.byteline.io/user/canny-token', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/canny-token");
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", "/api.byteline.io/user/canny-token", data)
    req.Header = headers

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

GET /user/canny-token

Example responses

200 Response

{
  "property1": "string",
  "property2": "string"
}

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

Status Code 200

Name Type Required Restrictions Description
» additionalProperties string false none none

userDashboard

Code samples


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

fetch('/api.byteline.io/user/dashboard',
{
  method: 'GET',

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

GET /api.byteline.io/user/dashboard HTTP/1.1

Accept: application/json

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

r = requests.get('/api.byteline.io/user/dashboard', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/dashboard");
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", "/api.byteline.io/user/dashboard", data)
    req.Header = headers

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

GET /user/dashboard

Example responses

200 Response

{
  "actionsConsumed": 0,
  "actionsLimit": 0,
  "currentPlan": "Free",
  "flows": [
    {
      "actionsConsumed": 0,
      "id": "string",
      "name": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK OK UserDashboardResponse
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

getUserData

Code samples


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

fetch('/api.byteline.io/user/data',
{
  method: 'GET',

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

GET /api.byteline.io/user/data HTTP/1.1

Accept: application/json

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

r = requests.get('/api.byteline.io/user/data', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/data");
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", "/api.byteline.io/user/data", data)
    req.Header = headers

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

GET /user/data

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

saveUserData

Code samples

const inputBody = '{}';
const headers = {
  'Content-Type':'application/json'
};

fetch('/api.byteline.io/user/data',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/user/data HTTP/1.1

Content-Type: application/json

import requests
headers = {
  'Content-Type': 'application/json'
}

r = requests.post('/api.byteline.io/user/data', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/data");
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"},
    }

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

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

POST /user/data

Body parameter

{}

Parameters

Name In Type Required Description
body body object true userData

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

newUserNotification

Code samples

const inputBody = '{
  "apiKey": "string",
  "apiKeyCreatedOn": "2021-09-20T17:39:01Z",
  "authTokens": [
    {
      "accessToken": "string",
      "accessTokenExpiry": "2021-09-20T17:39:01Z",
      "apiKey": "string",
      "issuer": "string",
      "refreshToken": "string",
      "scope": "string",
      "type": "string",
      "userInfo": {}
    }
  ],
  "billingPeriodEnds": "2021-09-20T17:39:01Z",
  "billingPeriodStarts": "2021-09-20T17:39:01Z",
  "billingPlan": "Free",
  "createdAt": "2021-09-20T17:39:01Z",
  "deleted": true,
  "displayName": "string",
  "email": "string",
  "familyName": "string",
  "givenName": "string",
  "stripeCustomerId": "string",
  "tourDone": true,
  "ttl": 0,
  "updatedAt": "2021-09-20T17:39:01Z",
  "userId": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'aUserId':'string'
};

fetch('/api.byteline.io/user/new',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /api.byteline.io/user/new HTTP/1.1

Content-Type: application/json

aUserId: string

import requests
headers = {
  'Content-Type': 'application/json',
  'aUserId': 'string'
}

r = requests.post('/api.byteline.io/user/new', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/new");
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"},
        "aUserId": []string{"string"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/user/new", data)
    req.Header = headers

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

POST /user/new

Body parameter

{
  "apiKey": "string",
  "apiKeyCreatedOn": "2021-09-20T17:39:01Z",
  "authTokens": [
    {
      "accessToken": "string",
      "accessTokenExpiry": "2021-09-20T17:39:01Z",
      "apiKey": "string",
      "issuer": "string",
      "refreshToken": "string",
      "scope": "string",
      "type": "string",
      "userInfo": {}
    }
  ],
  "billingPeriodEnds": "2021-09-20T17:39:01Z",
  "billingPeriodStarts": "2021-09-20T17:39:01Z",
  "billingPlan": "Free",
  "createdAt": "2021-09-20T17:39:01Z",
  "deleted": true,
  "displayName": "string",
  "email": "string",
  "familyName": "string",
  "givenName": "string",
  "stripeCustomerId": "string",
  "tourDone": true,
  "ttl": 0,
  "updatedAt": "2021-09-20T17:39:01Z",
  "userId": "string"
}

Parameters

Name In Type Required Description
aUserId header string true aUserId
body body User true newUser

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

reportActiveUsers

Code samples


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

fetch('/api.byteline.io/user/report-users',
{
  method: 'POST',

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

POST /api.byteline.io/user/report-users HTTP/1.1

Accept: application/json

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

r = requests.post('/api.byteline.io/user/report-users', headers = headers)

print(r.json())

URL obj = new URL("/api.byteline.io/user/report-users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/api.byteline.io/user/report-users", data)
    req.Header = headers

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

POST /user/report-users

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK OK Inline
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Response Schema

notifyTourCompleted

Code samples


fetch('/api.byteline.io/user/tour-done',
{
  method: 'PUT'

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

PUT /api.byteline.io/user/tour-done HTTP/1.1

import requests

r = requests.put('/api.byteline.io/user/tour-done')

print(r.json())

URL obj = new URL("/api.byteline.io/user/tour-done");
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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "/api.byteline.io/user/tour-done", data)
    req.Header = headers

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

PUT /user/tour-done

Responses

Status Meaning Description Schema
200 OK OK None
201 Created Created None
401 Unauthorized Unauthorized None
403 Forbidden Forbidden None
404 Not Found Not Found None

Schemas

ActionGroupResponse

{
  "displayName": "string",
  "name": "string"
}

ActionGroupResponse

Properties

Name Type Required Restrictions Description
displayName string false none none
name string false none none

AirtableTriggerDto

{
  "airtableApiKey": "string",
  "baseId": "string",
  "filter": {
    "comparisonOperation": "Equals",
    "filterInput": {
      "property1": "string",
      "property2": "string"
    },
    "selection": "None"
  },
  "pollRate": 0,
  "tableName": "string",
  "triggerType": "Create",
  "view": "string"
}

AirtableTriggerDto

Properties

Name Type Required Restrictions Description
airtableApiKey string false none none
baseId string false none none
filter RecordsFilter false none none
pollRate integer(int32) false none none
tableName string false none none
triggerType string false none none
view string false none none

Enumerated Values

Property Value
triggerType Create
triggerType Update

ArrayNode

{
  "array": true,
  "bigDecimal": true,
  "bigInteger": true,
  "binary": true,
  "boolean": true,
  "containerNode": true,
  "double": true,
  "empty": true,
  "float": true,
  "floatingPointNumber": true,
  "int": true,
  "integralNumber": true,
  "long": true,
  "missingNode": true,
  "nodeType": "ARRAY",
  "null": true,
  "number": true,
  "object": true,
  "pojo": true,
  "short": true,
  "textual": true,
  "valueNode": true
}

ArrayNode

Properties

Name Type Required Restrictions Description
array boolean false none none
bigDecimal boolean false none none
bigInteger boolean false none none
binary boolean false none none
boolean boolean false none none
containerNode boolean false none none
double boolean false none none
empty boolean false none none
float boolean false none none
floatingPointNumber boolean false none none
int boolean false none none
integralNumber boolean false none none
long boolean false none none
missingNode boolean false none none
nodeType string false none none
null boolean false none none
number boolean false none none
object boolean false none none
pojo boolean false none none
short boolean false none none
textual boolean false none none
valueNode boolean false none none

Enumerated Values

Property Value
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING

AuthIssuerItem

{
  "displayName": "string",
  "issuer": "string",
  "type": "string"
}

AuthIssuerItem

Properties

Name Type Required Restrictions Description
displayName string false none none
issuer string false none none
type string false none none

AuthToken

{
  "accessToken": "string",
  "accessTokenExpiry": "2021-09-20T17:39:01Z",
  "apiKey": "string",
  "issuer": "string",
  "refreshToken": "string",
  "scope": "string",
  "type": "string",
  "userInfo": {}
}

AuthToken

Properties

Name Type Required Restrictions Description
accessToken string false none none
accessTokenExpiry string(date-time) false none none
apiKey string false none none
issuer string false none none
refreshToken string false none none
scope string false none none
type string false none none
userInfo object false none none

AuthTokenResponseDto

{
  "apiKey": "string",
  "issuer": "string",
  "scope": "string",
  "type": "string"
}

AuthTokenResponseDto

Properties

Name Type Required Restrictions Description
apiKey string false none none
issuer string false none none
scope string false none none
type string false none none

CreateFlowRequest

{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "flowName": "string",
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}

CreateFlowRequest

Properties

Name Type Required Restrictions Description
config object false none none
» additionalProperties ObjectNode false none none
flowName string false none none
publicAccess boolean false none none
publicDescription string false none none
uiFlow UiFlow false none none

CreateScraperRequest

{
  "attributes": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "loopOver": "string",
  "maxPageLimit": 0,
  "name": "string",
  "paginationXPath": "string",
  "url": "string"
}

CreateScraperRequest

Properties

Name Type Required Restrictions Description
attributes [ScraperAttr] false none none
loopOver string false none none
maxPageLimit integer(int32) false none none
name string false none none
paginationXPath string false none none
url string false none none

FlowActionsDto

{
  "actionsConsumed": 0,
  "id": "string",
  "name": "string"
}

FlowActionsDto

Properties

Name Type Required Restrictions Description
actionsConsumed integer(int32) false none none
id string false none none
name string false none none

FlowDto

{
  "config": {
    "property1": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "property2": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  },
  "deployStatus": "Deployed",
  "flowId": "string",
  "flowImageUrl": "string",
  "flowName": "string",
  "pastNodeSuccessStatus": {
    "property1": true,
    "property2": true
  },
  "publicAccess": true,
  "publicDescription": "string",
  "uiFlow": {
    "edges": [
      {
        "data": {
          "array": true,
          "bigDecimal": true,
          "bigInteger": true,
          "binary": true,
          "boolean": true,
          "containerNode": true,
          "double": true,
          "empty": true,
          "float": true,
          "floatingPointNumber": true,
          "int": true,
          "integralNumber": true,
          "long": true,
          "missingNode": true,
          "nodeType": "ARRAY",
          "null": true,
          "number": true,
          "object": true,
          "pojo": true,
          "short": true,
          "textual": true,
          "valueNode": true
        },
        "source": "string",
        "target": "string"
      }
    ],
    "groups": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    },
    "nodes": [
      {
        "h": 0,
        "id": "string",
        "left": 0,
        "nodeType": "string",
        "top": 0,
        "type": "string",
        "w": 0
      }
    ],
    "ports": {
      "array": true,
      "bigDecimal": true,
      "bigInteger": true,
      "binary": true,
      "boolean": true,
      "containerNode": true,
      "double": true,
      "empty": true,
      "float": true,
      "floatingPointNumber": true,
      "int": true,
      "integralNumber": true,
      "long": true,
      "missingNode": true,
      "nodeType": "ARRAY",
      "null": true,
      "number": true,
      "object": true,
      "pojo": true,
      "short": true,
      "textual": true,
      "valueNode": true
    }
  }
}

FlowDto

Properties

Name Type Required Restrictions Description
config object false none none
» additionalProperties ObjectNode false none none
deployStatus string false none none
flowId string false none none
flowImageUrl string false none none
flowName string false none none
pastNodeSuccessStatus object false none none
» additionalProperties boolean false none none
publicAccess boolean false none none
publicDescription string false none none
uiFlow UiFlow false none none

Enumerated Values

Property Value
deployStatus Deployed
deployStatus Need_Redeploy
deployStatus Not_Deployed

FlowInstanceItem

{
  "actionsConsumed": 0,
  "entityType": "string",
  "flowDefId": "string",
  "flowInstanceId": "string",
  "input": {},
  "output": {},
  "startTime": "2021-09-20T17:39:01Z",
  "startedBy": "string",
  "status": "RUNNING",
  "taskResults": {
    "property1": {
      "actionGroupFlowInstanceId": "string",
      "output": {},
      "reasonForIncompletion": "string",
      "status": "RUNNING",
      "terminated": true,
      "timeTaken": 0,
      "timeTakenFromFlowStart": 0
    },
    "property2": {
      "actionGroupFlowInstanceId": "string",
      "output": {},
      "reasonForIncompletion": "string",
      "status": "RUNNING",
      "terminated": true,
      "timeTaken": 0,
      "timeTakenFromFlowStart": 0
    }
  },
  "terminated": true,
  "terminatedAt": "2021-09-20T17:39:01Z"
}

FlowInstanceItem

Properties

Name Type Required Restrictions Description
actionsConsumed integer(int32) false none none
entityType string false none none
flowDefId string false none none
flowInstanceId string false none none
input object false none none
output object false none none
startTime string(date-time) false none none
startedBy string false none none
status string false none none
taskResults object false none none
» additionalProperties TaskResultItem false none none
terminated boolean false none none
terminatedAt string(date-time) false none none

Enumerated Values

Property Value
status RUNNING
status COMPLETED
status FAILED
status SCHEDULED

IdName

{
  "id": "string",
  "name": "string"
}

IdName

Properties

Name Type Required Restrictions Description
id string false none none
name string false none none

JsonNode

{
  "array": true,
  "bigDecimal": true,
  "bigInteger": true,
  "binary": true,
  "boolean": true,
  "containerNode": true,
  "double": true,
  "empty": true,
  "float": true,
  "floatingPointNumber": true,
  "int": true,
  "integralNumber": true,
  "long": true,
  "missingNode": true,
  "nodeType": "ARRAY",
  "null": true,
  "number": true,
  "object": true,
  "pojo": true,
  "short": true,
  "textual": true,
  "valueNode": true
}

JsonNode

Properties

Name Type Required Restrictions Description
array boolean false none none
bigDecimal boolean false none none
bigInteger boolean false none none
binary boolean false none none
boolean boolean false none none
containerNode boolean false none none
double boolean false none none
empty boolean false none none
float boolean false none none
floatingPointNumber boolean false none none
int boolean false none none
integralNumber boolean false none none
long boolean false none none
missingNode boolean false none none
nodeType string false none none
null boolean false none none
number boolean false none none
object boolean false none none
pojo boolean false none none
short boolean false none none
textual boolean false none none
valueNode boolean false none none

Enumerated Values

Property Value
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING

NodeTypeRequest

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

NodeTypeRequest

Properties

Name Type Required Restrictions Description
actionGroupFlowId string false none none
category string true none none
configRequired boolean false none none
displayName string false none none
flowEngineType string true none none
internal boolean false none none
link string false none none
logoSquareUri string false none none
logoUri string false none none
loopOverOptions [string] false none none
name string false none none
order integer(int32) true none none
outputTemplate JsonNode false none none
purpose string true none none
statement string false none none
timeoutSecs integer(int64) true none none
ui ObjectNode false none none

Enumerated Values

Property Value
category Built_In
category CRM
category Business_Intelligence
category Productivity
category Communication
category Marketing
category Database
category Financial
category Social
category Analytics
category Traveling
category CMS
flowEngineType SIMPLE
flowEngineType DECISION
flowEngineType LAMBDA
flowEngineType DO_WHILE
flowEngineType WAIT
flowEngineType BYTELINE
flowEngineType JSON_JQ_TRANSFORM
purpose Action
purpose Trigger

NodeTypeResponse

{
  "actionGroupFlowId": "string",
  "category": "Built_In",
  "configRequired": true,
  "displayName": "string",
  "flowEngineType": "SIMPLE",
  "internal": true,
  "link": "string",
  "logoSquareUri": "string",
  "logoUri": "string",
  "loopOverOptions": [
    "string"
  ],
  "name": "string",
  "order": 0,
  "outputTemplate": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "purpose": "Action",
  "statement": "string",
  "timeoutSecs": 0,
  "ui": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

NodeTypeResponse

Properties

Name Type Required Restrictions Description
actionGroupFlowId string false none none
category string false none none
configRequired boolean false none none
displayName string false none none
flowEngineType string false none none
internal boolean false none none
link string false none none
logoSquareUri string false none none
logoUri string false none none
loopOverOptions [string] false none none
name string false none none
order integer(int32) false none none
outputTemplate JsonNode false none none
purpose string false none none
statement string false none none
timeoutSecs integer(int64) false none none
ui ObjectNode false none none

Enumerated Values

Property Value
category Built_In
category CRM
category Business_Intelligence
category Productivity
category Communication
category Marketing
category Database
category Financial
category Social
category Analytics
category Traveling
category CMS
flowEngineType SIMPLE
flowEngineType DECISION
flowEngineType LAMBDA
flowEngineType DO_WHILE
flowEngineType WAIT
flowEngineType BYTELINE
flowEngineType JSON_JQ_TRANSFORM
purpose Action
purpose Trigger

ObjectNode

{
  "array": true,
  "bigDecimal": true,
  "bigInteger": true,
  "binary": true,
  "boolean": true,
  "containerNode": true,
  "double": true,
  "empty": true,
  "float": true,
  "floatingPointNumber": true,
  "int": true,
  "integralNumber": true,
  "long": true,
  "missingNode": true,
  "nodeType": "ARRAY",
  "null": true,
  "number": true,
  "object": true,
  "pojo": true,
  "short": true,
  "textual": true,
  "valueNode": true
}

ObjectNode

Properties

Name Type Required Restrictions Description
array boolean false none none
bigDecimal boolean false none none
bigInteger boolean false none none
binary boolean false none none
boolean boolean false none none
containerNode boolean false none none
double boolean false none none
empty boolean false none none
float boolean false none none
floatingPointNumber boolean false none none
int boolean false none none
integralNumber boolean false none none
long boolean false none none
missingNode boolean false none none
nodeType string false none none
null boolean false none none
number boolean false none none
object boolean false none none
pojo boolean false none none
short boolean false none none
textual boolean false none none
valueNode boolean false none none

Enumerated Values

Property Value
nodeType ARRAY
nodeType BINARY
nodeType BOOLEAN
nodeType MISSING
nodeType NULL
nodeType NUMBER
nodeType OBJECT
nodeType POJO
nodeType STRING

RecordsFilter

{
  "comparisonOperation": "Equals",
  "filterInput": {
    "property1": "string",
    "property2": "string"
  },
  "selection": "None"
}

RecordsFilter

Properties

Name Type Required Restrictions Description
comparisonOperation string false none none
filterInput object false none none
» additionalProperties string false none none
selection string false none none

Enumerated Values

Property Value
comparisonOperation Equals
comparisonOperation NotEquals
comparisonOperation Contains
comparisonOperation NotContains
selection None
selection Filter

ScraperArrayAttr

{
  "name": "string",
  "type": "string",
  "children": [
    {
      "name": "string",
      "type": "string",
      "xpath": "string"
    }
  ],
  "iterableParentXPath": "string"
}

ScraperArrayAttr

Properties

Name Type Required Restrictions Description
ScraperArrayAttr any false none none

allOf

Name Type Required Restrictions Description
anonymous ScraperAttr false none none

and

Name Type Required Restrictions Description
anonymous object false none none
» children [ScraperScalarAttr] false none none
» iterableParentXPath string false none none
» name string false none none
» type string false none none

ScraperAttr

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

ScraperAttr

Properties

Name Type Required Restrictions Description
name string false none none
type string false none none

ScraperItem

{
  "attributes": [
    {
      "name": "string",
      "type": "string"
    }
  ],
  "entityType": "string",
  "id": "string",
  "maxPageLimit": 0,
  "name": "string",
  "paginationXPath": "string",
  "url": "string"
}

ScraperItem

Properties

Name Type Required Restrictions Description
attributes [ScraperAttr] false none none
entityType string false none none
id string false none none
maxPageLimit integer(int32) false none none
name string false none none
paginationXPath string false none none
url string false none none

ScraperIterableXpathDto

{
  "repeatingXPaths": [
    "string"
  ],
  "url": "string"
}

ScraperIterableXpathDto

Properties

Name Type Required Restrictions Description
repeatingXPaths [string] false none none
url string false none none

ScraperScalarAttr

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

ScraperScalarAttr

Properties

Name Type Required Restrictions Description
ScraperScalarAttr any false none none

allOf

Name Type Required Restrictions Description
anonymous ScraperAttr false none none

and

Name Type Required Restrictions Description
anonymous object false none none
» name string false none none
» type string false none none
» xpath string false none none

ScraperUrlCheck

{
  "allowed": true,
  "robotsTxtUrl": "string"
}

ScraperUrlCheck

Properties

Name Type Required Restrictions Description
allowed boolean false none none
robotsTxtUrl string false none none

SimpleFlowDto

{
  "flowId": "string",
  "flowName": "string"
}

SimpleFlowDto

Properties

Name Type Required Restrictions Description
flowId string false none none
flowName string false none none

TaskResultItem

{
  "actionGroupFlowInstanceId": "string",
  "output": {},
  "reasonForIncompletion": "string",
  "status": "RUNNING",
  "terminated": true,
  "timeTaken": 0,
  "timeTakenFromFlowStart": 0
}

TaskResultItem

Properties

Name Type Required Restrictions Description
actionGroupFlowInstanceId string false none none
output object false none none
reasonForIncompletion string false none none
status string false none none
terminated boolean false none none
timeTaken integer(int64) false none none
timeTakenFromFlowStart integer(int64) false none none

Enumerated Values

Property Value
status RUNNING
status COMPLETED
status FAILED
status SCHEDULED

UiEdge

{
  "data": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "source": "string",
  "target": "string"
}

UiEdge

Properties

Name Type Required Restrictions Description
data ObjectNode false none none
source string false none none
target string false none none

UiFlow

{
  "edges": [
    {
      "data": {
        "array": true,
        "bigDecimal": true,
        "bigInteger": true,
        "binary": true,
        "boolean": true,
        "containerNode": true,
        "double": true,
        "empty": true,
        "float": true,
        "floatingPointNumber": true,
        "int": true,
        "integralNumber": true,
        "long": true,
        "missingNode": true,
        "nodeType": "ARRAY",
        "null": true,
        "number": true,
        "object": true,
        "pojo": true,
        "short": true,
        "textual": true,
        "valueNode": true
      },
      "source": "string",
      "target": "string"
    }
  ],
  "groups": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  },
  "nodes": [
    {
      "h": 0,
      "id": "string",
      "left": 0,
      "nodeType": "string",
      "top": 0,
      "type": "string",
      "w": 0
    }
  ],
  "ports": {
    "array": true,
    "bigDecimal": true,
    "bigInteger": true,
    "binary": true,
    "boolean": true,
    "containerNode": true,
    "double": true,
    "empty": true,
    "float": true,
    "floatingPointNumber": true,
    "int": true,
    "integralNumber": true,
    "long": true,
    "missingNode": true,
    "nodeType": "ARRAY",
    "null": true,
    "number": true,
    "object": true,
    "pojo": true,
    "short": true,
    "textual": true,
    "valueNode": true
  }
}

UiFlow

Properties

Name Type Required Restrictions Description
edges [UiEdge] false none none
groups ArrayNode false none none
nodes [UiNode] false none none
ports ArrayNode false none none

UiNode

{
  "h": 0,
  "id": "string",
  "left": 0,
  "nodeType": "string",
  "top": 0,
  "type": "string",
  "w": 0
}

UiNode

Properties

Name Type Required Restrictions Description
h integer(int32) false none none
id string false none none
left integer(int32) false none none
nodeType string false none none
top integer(int32) false none none
type string false none none
w integer(int32) false none none

UploadFlowImageDto

{
  "data": "string",
  "extension": "string"
}

UploadFlowImageDto

Properties

Name Type Required Restrictions Description
data string(byte) true none none
extension string false none none

User

{
  "apiKey": "string",
  "apiKeyCreatedOn": "2021-09-20T17:39:01Z",
  "authTokens": [
    {
      "accessToken": "string",
      "accessTokenExpiry": "2021-09-20T17:39:01Z",
      "apiKey": "string",
      "issuer": "string",
      "refreshToken": "string",
      "scope": "string",
      "type": "string",
      "userInfo": {}
    }
  ],
  "billingPeriodEnds": "2021-09-20T17:39:01Z",
  "billingPeriodStarts": "2021-09-20T17:39:01Z",
  "billingPlan": "Free",
  "createdAt": "2021-09-20T17:39:01Z",
  "deleted": true,
  "displayName": "string",
  "email": "string",
  "familyName": "string",
  "givenName": "string",
  "stripeCustomerId": "string",
  "tourDone": true,
  "ttl": 0,
  "updatedAt": "2021-09-20T17:39:01Z",
  "userId": "string"
}

User

Properties

Name Type Required Restrictions Description
apiKey string false none none
apiKeyCreatedOn string(date-time) false none none
authTokens [AuthToken] false none none
billingPeriodEnds string(date-time) false none none
billingPeriodStarts string(date-time) false none none
billingPlan string false none none
createdAt string(date-time) false none none
deleted boolean false none none
displayName string false none none
email string false none none
familyName string false none none
givenName string false none none
stripeCustomerId string false none none
tourDone boolean false none none
ttl integer(int64) false none none
updatedAt string(date-time) false none none
userId string false none none

Enumerated Values

Property Value
billingPlan Free
billingPlan Basic
billingPlan Standard
billingPlan Growth
billingPlan Pro
billingPlan Business

UserDashboardResponse

{
  "actionsConsumed": 0,
  "actionsLimit": 0,
  "currentPlan": "Free",
  "flows": [
    {
      "actionsConsumed": 0,
      "id": "string",
      "name": "string"
    }
  ]
}

UserDashboardResponse

Properties

Name Type Required Restrictions Description
actionsConsumed integer(int32) false none none
actionsLimit integer(int32) false none none
currentPlan string false none none
flows [FlowActionsDto] false none none

Enumerated Values

Property Value
currentPlan Free
currentPlan Basic
currentPlan Standard
currentPlan Growth
currentPlan Pro
currentPlan Business

Map_string_string_

{
  "property1": "string",
  "property2": "string"
}

Map«string,string»

Properties

Name Type Required Restrictions Description
additionalProperties string false none none