NAV
Python Go HTTP JavaScript Node.js

MLS API version not set

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

Authentication

AccountingService

Returns a list of invoices

Code samples

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

r = requests.get('/accounting/v1beta1/invoices', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/accounting/v1beta1/invoices", data)
    req.Header = headers

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

GET /accounting/v1beta1/invoices HTTP/1.1

Accept: application/json


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

fetch('/accounting/v1beta1/invoices',
{
  method: 'GET',

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

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

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

fetch('/accounting/v1beta1/invoices',
{
  method: 'GET',

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

GET /accounting/v1beta1/invoices

List all the invoices connected to your account.

Parameters

Name In Type Required Description
start_time query string(date-time) false The filter is applied to issue_time.
end_time query string(date-time) false The filter is applied to issue_time.

Example responses

200 Response

{
  "invoices": [
    {
      "amount": 0,
      "currency": "string",
      "due_time": "2019-08-24T14:15:22Z",
      "end_time": "2019-08-24T14:15:22Z",
      "id": "string",
      "issue_time": "2019-08-24T14:15:22Z",
      "org_id": "string",
      "start_time": "2019-08-24T14:15:22Z",
      "status": "STATUS_UNSPECIFIED",
      "update_time": "2019-08-24T14:15:22Z",
      "usages": [
        {
          "amount": 0,
          "amount_unit": "AMOUNT_UNIT_UNSPECIFIED",
          "cost": {
            "amount": 0,
            "currency": "string"
          },
          "description": "string",
          "end_time": "2019-08-24T14:15:22Z",
          "sku_id": "string",
          "start_time": "2019-08-24T14:15:22Z"
        }
      ]
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.accounting.v1beta1.ListInvoicesResponse
default Default An unexpected error response. google.rpc.Status

Download an invoice

Code samples

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

r = requests.get('/accounting/v1beta1/invoices/{invoice_id}/download', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/accounting/v1beta1/invoices/{invoice_id}/download", data)
    req.Header = headers

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

GET /accounting/v1beta1/invoices/{invoice_id}/download HTTP/1.1

Accept: application/json


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

fetch('/accounting/v1beta1/invoices/{invoice_id}/download',
{
  method: 'GET',

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

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

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

fetch('/accounting/v1beta1/invoices/{invoice_id}/download',
{
  method: 'GET',

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

GET /accounting/v1beta1/invoices/{invoice_id}/download

Generates and return a downloadable URL of invoice.

Parameters

Name In Type Required Description
invoice_id path string true Unique id of the invoice.

Example responses

200 Response

{
  "download_url": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.accounting.v1beta1.DownloadInvoiceResponse
default Default An unexpected error response. google.rpc.Status

Returns a list of skus usages

Code samples

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

r = requests.get('/accounting/v1beta1/usages', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/accounting/v1beta1/usages", data)
    req.Header = headers

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

GET /accounting/v1beta1/usages HTTP/1.1

Accept: application/json


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

fetch('/accounting/v1beta1/usages',
{
  method: 'GET',

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

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

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

fetch('/accounting/v1beta1/usages',
{
  method: 'GET',

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

GET /accounting/v1beta1/usages

List all the SKUs usages connected to your account.

Parameters

Name In Type Required Description
aggregate query boolean false Aggregate multi SKUs with the same ID in one result.
start_time query string(date-time) false The filter applies to start_time.
end_time query string(date-time) false The filter applies to end_time.
page_size query integer(int32) false A positive number that is the maximum number of results to return.
page_token query string false If this field is not empty then it must contain the next_page_token value

Detailed descriptions

page_token: If this field is not empty then it must contain the next_page_token value returned by a previous call to this method. Using this field causes the method to return additional results from the previous method call.

Example responses

200 Response

{
  "next_page_token": "string",
  "usages": [
    {
      "amount": 0,
      "end_time": "2019-08-24T14:15:22Z",
      "sku_id": "string",
      "start_time": "2019-08-24T14:15:22Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.accounting.v1beta1.ListSKUUsageResponse
default Default An unexpected error response. google.rpc.Status

Returns a list of running skus usages for the current period

Code samples

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

r = requests.get('/accounting/v1beta1/usages/running', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/accounting/v1beta1/usages/running", data)
    req.Header = headers

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

GET /accounting/v1beta1/usages/running HTTP/1.1

Accept: application/json


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

fetch('/accounting/v1beta1/usages/running',
{
  method: 'GET',

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

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

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

fetch('/accounting/v1beta1/usages/running',
{
  method: 'GET',

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

GET /accounting/v1beta1/usages/running

List all the SKUs usages connected to your account. You used them previusely.

Example responses

200 Response

{
  "amount": 0,
  "currency": "string",
  "end_time": "2019-08-24T14:15:22Z",
  "start_time": "2019-08-24T14:15:22Z",
  "update_time": "2019-08-24T14:15:22Z",
  "usages": [
    {
      "amount": 0,
      "amount_unit": "AMOUNT_UNIT_UNSPECIFIED",
      "cost": {
        "amount": 0,
        "currency": "string"
      },
      "description": "string",
      "end_time": "2019-08-24T14:15:22Z",
      "sku_id": "string",
      "start_time": "2019-08-24T14:15:22Z"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.accounting.v1beta1.ListRunningSKUUsageResponse
default Default An unexpected error response. google.rpc.Status

ActionsService

Lists actions

Code samples

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

r = requests.get('/actions/v1beta1', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /actions/v1beta1 HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1',
{
  method: 'GET',

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

GET /actions/v1beta1

List all the actions

Parameters

Name In Type Required Description
service_id query string false Filter list by service ID.
category_id query string false Filter list by category ID.
page_size query integer(int32) false Maximum number of records to return.
page_token query string false The pagination token in the List request.

Example responses

200 Response

{
  "items": [
    {
      "category_id": "string",
      "description": "string",
      "icon_url": "string",
      "id": "string",
      "is_active": true,
      "service_id": "string",
      "title": "string"
    }
  ],
  "next_page_token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.ListActionsResponse
default Default An unexpected error response. google.rpc.Status

Lists action calls

Code samples

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

r = requests.get('/actions/v1beta1/calls', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/actions/v1beta1/calls", data)
    req.Header = headers

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

GET /actions/v1beta1/calls HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/calls',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1/calls',
{
  method: 'GET',

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

GET /actions/v1beta1/calls

List all action calls

Parameters

Name In Type Required Description
group_id query string false none

Example responses

200 Response

{
  "items": [
    {
      "configuration_id": "string",
      "group_id": "string",
      "id": "string",
      "request_data_id": "string",
      "response_data_id": "string",
      "state": "ACTION_CALL_STATE_UNSPECIFIED"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.ListActionCallsResponse
default Default An unexpected error response. google.rpc.Status

Returns a single action call

Code samples

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

r = requests.get('/actions/v1beta1/calls/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/actions/v1beta1/calls/{id}", data)
    req.Header = headers

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

GET /actions/v1beta1/calls/{id} HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/calls/{id}',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1/calls/{id}',
{
  method: 'GET',

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

GET /actions/v1beta1/calls/{id}

Returns a single action call.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "action_call": {
    "configuration_id": "string",
    "group_id": "string",
    "id": "string",
    "request_data_id": "string",
    "response_data_id": "string",
    "state": "ACTION_CALL_STATE_UNSPECIFIED"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.GetActionCallResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Updates an action call

Code samples

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

r = requests.patch('/actions/v1beta1/calls/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/actions/v1beta1/calls/{id}", data)
    req.Header = headers

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

PATCH /actions/v1beta1/calls/{id} HTTP/1.1

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

const inputBody = '{
  "data": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/actions/v1beta1/calls/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "data": {}
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/actions/v1beta1/calls/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /actions/v1beta1/calls/{id}

Updates an action call.

Body parameter

{
  "data": {}
}

Parameters

Name In Type Required Description
id path string true none
update_mask query array[string] false Optional. The mask to control which fields get updated.
body body mycujoo.actions.v1beta1.UpdateActionCallRequestFields true Fields to update

Example responses

200 Response

{
  "action_call": {
    "configuration_id": "string",
    "group_id": "string",
    "id": "string",
    "request_data_id": "string",
    "response_data_id": "string",
    "state": "ACTION_CALL_STATE_UNSPECIFIED"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.UpdateActionCallResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Lists action categories

Code samples

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

r = requests.get('/actions/v1beta1/categories', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/actions/v1beta1/categories", data)
    req.Header = headers

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

GET /actions/v1beta1/categories HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/categories',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1/categories',
{
  method: 'GET',

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

GET /actions/v1beta1/categories

List all the available categories of actions

Parameters

Name In Type Required Description
page_size query integer(int32) false Maximum number of records to return.
page_token query string false The pagination token in the List request.
hide_empty query boolean false Whether to filter out categories with no available actions.

Example responses

200 Response

{
  "items": [
    {
      "description": "string",
      "id": "string",
      "menu_title": "string",
      "title": "string"
    }
  ],
  "next_page_token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.ListActionCategoriesResponse
default Default An unexpected error response. google.rpc.Status

Lists action configurations

Code samples

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

r = requests.get('/actions/v1beta1/configurations', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/actions/v1beta1/configurations", data)
    req.Header = headers

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

GET /actions/v1beta1/configurations HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/configurations',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1/configurations',
{
  method: 'GET',

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

GET /actions/v1beta1/configurations

List all the action configurations of a group

Parameters

Name In Type Required Description
group_id query string false none

Example responses

200 Response

{
  "items": [
    {
      "action_id": "string",
      "action_title": "string",
      "group_id": "string",
      "id": "string",
      "order": 0,
      "title": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.ListActionConfigurationsResponse
default Default An unexpected error response. google.rpc.Status

Creates an action configuration

Code samples

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

r = requests.post('/actions/v1beta1/configurations', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/actions/v1beta1/configurations", data)
    req.Header = headers

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

POST /actions/v1beta1/configurations HTTP/1.1

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

const inputBody = '{
  "action_id": "string",
  "fields": [
    {
      "dynamic_action_value": {
        "data_source": "string",
        "path": "string"
      },
      "field": "string",
      "static_action_value": {
        "bool_value": true,
        "datetime_value": "2019-08-24T14:15:22Z",
        "float_value": 0,
        "number_value": "string",
        "string_value": "string"
      }
    }
  ],
  "group_id": "string",
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/actions/v1beta1/configurations',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "action_id": "string",
  "fields": [
    {
      "dynamic_action_value": {
        "data_source": "string",
        "path": "string"
      },
      "field": "string",
      "static_action_value": {
        "bool_value": true,
        "datetime_value": "2019-08-24T14:15:22Z",
        "float_value": 0,
        "number_value": "string",
        "string_value": "string"
      }
    }
  ],
  "group_id": "string",
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/actions/v1beta1/configurations',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /actions/v1beta1/configurations

Creates a new action configuration.

Body parameter

{
  "action_id": "string",
  "fields": [
    {
      "dynamic_action_value": {
        "data_source": "string",
        "path": "string"
      },
      "field": "string",
      "static_action_value": {
        "bool_value": true,
        "datetime_value": "2019-08-24T14:15:22Z",
        "float_value": 0,
        "number_value": "string",
        "string_value": "string"
      }
    }
  ],
  "group_id": "string",
  "title": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.actions.v1beta1.CreateActionConfigurationRequest true none

Example responses

200 Response

{
  "action_configuration": {
    "action_id": "string",
    "fields": [
      {
        "dynamic_action_value": {
          "data_source": "string",
          "path": "string"
        },
        "field": "string",
        "static_action_value": {
          "bool_value": true,
          "datetime_value": "2019-08-24T14:15:22Z",
          "float_value": 0,
          "number_value": "string",
          "string_value": "string"
        }
      }
    ],
    "group_id": "string",
    "id": "string",
    "order": 0,
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.CreateActionConfigurationResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Returns a single action configuration

Code samples

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

r = requests.get('/actions/v1beta1/configurations/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/actions/v1beta1/configurations/{id}", data)
    req.Header = headers

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

GET /actions/v1beta1/configurations/{id} HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/configurations/{id}',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1/configurations/{id}',
{
  method: 'GET',

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

GET /actions/v1beta1/configurations/{id}

Returns a single action type.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "action_configuration": {
    "action_id": "string",
    "fields": [
      {
        "dynamic_action_value": {
          "data_source": "string",
          "path": "string"
        },
        "field": "string",
        "static_action_value": {
          "bool_value": true,
          "datetime_value": "2019-08-24T14:15:22Z",
          "float_value": 0,
          "number_value": "string",
          "string_value": "string"
        }
      }
    ],
    "group_id": "string",
    "id": "string",
    "order": 0,
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.GetActionConfigurationResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Deletes an action configuration

Code samples

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

r = requests.delete('/actions/v1beta1/configurations/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/actions/v1beta1/configurations/{id}", data)
    req.Header = headers

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

DELETE /actions/v1beta1/configurations/{id} HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/configurations/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/actions/v1beta1/configurations/{id}',
{
  method: 'DELETE',

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

DELETE /actions/v1beta1/configurations/{id}

Deletes an action configuration.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.DeleteActionConfigurationResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Updates an action configuration

Code samples

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

r = requests.patch('/actions/v1beta1/configurations/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/actions/v1beta1/configurations/{id}", data)
    req.Header = headers

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

PATCH /actions/v1beta1/configurations/{id} HTTP/1.1

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

const inputBody = '{
  "fields": [
    {
      "dynamic_action_value": {
        "data_source": "string",
        "path": "string"
      },
      "field": "string",
      "static_action_value": {
        "bool_value": true,
        "datetime_value": "2019-08-24T14:15:22Z",
        "float_value": 0,
        "number_value": "string",
        "string_value": "string"
      }
    }
  ],
  "order": 0,
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/actions/v1beta1/configurations/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "fields": [
    {
      "dynamic_action_value": {
        "data_source": "string",
        "path": "string"
      },
      "field": "string",
      "static_action_value": {
        "bool_value": true,
        "datetime_value": "2019-08-24T14:15:22Z",
        "float_value": 0,
        "number_value": "string",
        "string_value": "string"
      }
    }
  ],
  "order": 0,
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/actions/v1beta1/configurations/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /actions/v1beta1/configurations/{id}

Updates an action configuration.

Body parameter

{
  "fields": [
    {
      "dynamic_action_value": {
        "data_source": "string",
        "path": "string"
      },
      "field": "string",
      "static_action_value": {
        "bool_value": true,
        "datetime_value": "2019-08-24T14:15:22Z",
        "float_value": 0,
        "number_value": "string",
        "string_value": "string"
      }
    }
  ],
  "order": 0,
  "title": "string"
}

Parameters

Name In Type Required Description
id path string true none
update_mask query array[string] false Optional. The mask to control which fields get updated.
body body mycujoo.actions.v1beta1.UpdateActionConfigurationRequestFields true Fields to update

Example responses

200 Response

{
  "action_configuration": {
    "action_id": "string",
    "fields": [
      {
        "dynamic_action_value": {
          "data_source": "string",
          "path": "string"
        },
        "field": "string",
        "static_action_value": {
          "bool_value": true,
          "datetime_value": "2019-08-24T14:15:22Z",
          "float_value": 0,
          "number_value": "string",
          "string_value": "string"
        }
      }
    ],
    "group_id": "string",
    "id": "string",
    "order": 0,
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.UpdateActionConfigurationResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Returns a single action

Code samples

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

r = requests.get('/actions/v1beta1/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/actions/v1beta1/{id}", data)
    req.Header = headers

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

GET /actions/v1beta1/{id} HTTP/1.1

Accept: application/json


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

fetch('/actions/v1beta1/{id}',
{
  method: 'GET',

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

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

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

fetch('/actions/v1beta1/{id}',
{
  method: 'GET',

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

GET /actions/v1beta1/{id}

Returns a single action

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "action": {
    "action_fields": [
      {
        "dynamic_value": {
          "data_source": "string",
          "path": "string"
        },
        "is_configurable": true,
        "is_required": true,
        "label": "string",
        "name": "string",
        "no_default_value": true,
        "source_type": "DATA_SOURCE_TYPE_UNSPECIFIED",
        "static_value": {
          "bool_value": true,
          "datetime_value": "2019-08-24T14:15:22Z",
          "float_value": 0,
          "number_value": "string",
          "string_value": "string"
        },
        "validators": [
          {
            "max": 0,
            "min": 0,
            "regex": "string"
          }
        ],
        "value_options": [
          {
            "label": "string",
            "value": {
              "bool_value": true,
              "datetime_value": "2019-08-24T14:15:22Z",
              "float_value": 0,
              "number_value": "string",
              "string_value": "string"
            }
          }
        ],
        "value_type": "VALUE_TYPE_UNSPECIFIED"
      }
    ],
    "category_id": "string",
    "description": "string",
    "icon_url": "string",
    "id": "string",
    "is_active": true,
    "request_schema_id": "string",
    "request_topic": "string",
    "response_schema_id": "string",
    "response_topic": "string",
    "service_id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.actions.v1beta1.GetActionResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

StreamingAnalyticsService

Get concurrent plays historical data for a stream

Code samples

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

r = requests.get('/analytics/v1beta1/streams/{stream_id}/concurrent-plays', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/analytics/v1beta1/streams/{stream_id}/concurrent-plays", data)
    req.Header = headers

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

GET /analytics/v1beta1/streams/{stream_id}/concurrent-plays HTTP/1.1

Accept: application/json


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

fetch('/analytics/v1beta1/streams/{stream_id}/concurrent-plays',
{
  method: 'GET',

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

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

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

fetch('/analytics/v1beta1/streams/{stream_id}/concurrent-plays',
{
  method: 'GET',

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

GET /analytics/v1beta1/streams/{stream_id}/concurrent-plays

Get historical data about a stream's concurrent plays within a time range.

Parameters

Name In Type Required Description
stream_id path string true example: ck8u9fwwu1wtg0hewiqz3we6j
start_time query string(date-time) false Start date to retrieve concurrent plays, this is optional.
end_time query string(date-time) false End date to retrieve concurrent plays, this is optional.

Detailed descriptions

start_time: Start date to retrieve concurrent plays, this is optional. If not provided by the user, start_date will become the stream's starting date.

end_time: End date to retrieve concurrent plays, this is optional. If not provided by the user, end_date will become the stream's end date.

Example responses

200 Response

{
  "concurrent_plays": [
    {
      "plays": 0,
      "time": "2019-08-24T14:15:22Z"
    }
  ],
  "stream_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.analytics.v1beta1.GetConcurrentPlaysHistoryResponse
default Default An unexpected error response. google.rpc.Status

AnnotationService

List annotations

Code samples

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

r = requests.get('/annotations/v1beta1', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /annotations/v1beta1 HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1',
{
  method: 'GET',

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

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

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

fetch('/annotations/v1beta1',
{
  method: 'GET',

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

GET /annotations/v1beta1

List all the annotations from an account.

Parameters

Name In Type Required Description
timeline_id query string false none
page_size query integer(int32) false A positive number that is the maximum number of results to return.
page_token query string false empty or containing the "next_page_token" from a previous call.
order_by query string false Specifies the result ordering for List requests.
includes query array[string] false Specifies what response metadata should include.

Detailed descriptions

order_by: Specifies the result ordering for List requests.

includes: Specifies what response metadata should include. e.g. when 'INCLUDE_TOTAL_SIZE' is passed, response metadata will include total size of the result.

Enumerated Values

Parameter Value
order_by ORDER_UNSPECIFIED
order_by ORDER_OFFSET_ASC
order_by ORDER_OFFSET_DESC
includes INCLUDE_UNSPECIFIED
includes INCLUDE_TOTAL_SIZE

Example responses

200 Response

{
  "annotations": [
    {
      "action_call_ids": [
        "string"
      ],
      "create_time": "2019-08-24T14:15:22Z",
      "id": "string",
      "offset": "string",
      "timeline_id": "string",
      "type_id": "string"
    }
  ],
  "next_page_token": "string",
  "total_size": 0
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.ListAnnotationsResponse
default Default An unexpected error response. google.rpc.Status

Creates an annotation

Code samples

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

r = requests.post('/annotations/v1beta1', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

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

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

POST /annotations/v1beta1 HTTP/1.1

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

const inputBody = '{
  "offset": "string",
  "timeline_id": "string",
  "type_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "offset": "string",
  "timeline_id": "string",
  "type_id": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /annotations/v1beta1

Creates a new annotation from a type on a timeline.

Body parameter

{
  "offset": "string",
  "timeline_id": "string",
  "type_id": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.annotations.v1beta1.CreateAnnotationRequest true none

Example responses

200 Response

{
  "annotation": {
    "action_call_ids": [
      "string"
    ],
    "create_time": "2019-08-24T14:15:22Z",
    "id": "string",
    "offset": "string",
    "timeline_id": "string",
    "type_id": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.CreateAnnotationResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Lists annotation sets

Code samples

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

r = requests.get('/annotations/v1beta1/sets', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/annotations/v1beta1/sets", data)
    req.Header = headers

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

GET /annotations/v1beta1/sets HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/sets',
{
  method: 'GET',

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

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

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

fetch('/annotations/v1beta1/sets',
{
  method: 'GET',

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

GET /annotations/v1beta1/sets

List all the annotation sets from an account.

Parameters

Name In Type Required Description
page_size query integer(int32) false A positive number that is the maximum number of results to return.
page_token query string false empty or containing the "next_page_token" from a previous call.
order_by query string false Specifies the result ordering for List requests.
includes query array[string] false Specifies what response metadata should include.

Detailed descriptions

order_by: Specifies the result ordering for List requests.

includes: Specifies what response metadata should include. e.g. when 'INCLUDE_TOTAL_SIZE' is passed, response metadata will include total size of the result.

Enumerated Values

Parameter Value
order_by ORDER_TITLE_UNSPECIFIED
order_by ORDER_TITLE_ASC
order_by ORDER_TITLE_DESC
includes INCLUDE_UNSPECIFIED
includes INCLUDE_TOTAL_SIZE

Example responses

200 Response

{
  "next_page_token": "string",
  "sets": [
    {
      "id": "string",
      "title": "string"
    }
  ],
  "total_size": 0
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.ListAnnotationSetsResponse
default Default An unexpected error response. google.rpc.Status

Creates a new annotation set

Code samples

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

r = requests.post('/annotations/v1beta1/sets', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/annotations/v1beta1/sets", data)
    req.Header = headers

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

POST /annotations/v1beta1/sets HTTP/1.1

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

const inputBody = '{
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/sets',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/sets',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /annotations/v1beta1/sets

Creates a new annotation set.

Body parameter

{
  "title": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.annotations.v1beta1.CreateAnnotationSetRequest true none

Example responses

200 Response

{
  "set": {
    "id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.CreateAnnotationSetResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Returns a single annotation set

Code samples

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

r = requests.get('/annotations/v1beta1/sets/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/annotations/v1beta1/sets/{id}", data)
    req.Header = headers

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

GET /annotations/v1beta1/sets/{id} HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/sets/{id}',
{
  method: 'GET',

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

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

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

fetch('/annotations/v1beta1/sets/{id}',
{
  method: 'GET',

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

GET /annotations/v1beta1/sets/{id}

Returns a single annotation set.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "set": {
    "id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.GetAnnotationSetResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Deletes an annotation set

Code samples

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

r = requests.delete('/annotations/v1beta1/sets/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/annotations/v1beta1/sets/{id}", data)
    req.Header = headers

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

DELETE /annotations/v1beta1/sets/{id} HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/sets/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/annotations/v1beta1/sets/{id}',
{
  method: 'DELETE',

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

DELETE /annotations/v1beta1/sets/{id}

Deletes an annotation set.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.DeleteAnnotationSetResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Updates an annotation set

Code samples

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

r = requests.patch('/annotations/v1beta1/sets/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/annotations/v1beta1/sets/{id}", data)
    req.Header = headers

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

PATCH /annotations/v1beta1/sets/{id} HTTP/1.1

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

const inputBody = '{
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/sets/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/sets/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /annotations/v1beta1/sets/{id}

Updates an annotation set.

Body parameter

{
  "title": "string"
}

Parameters

Name In Type Required Description
id path string true ID of the annotation set to update
update_mask query array[string] false Optional. The mask to control which fields get updated.
body body mycujoo.annotations.v1beta1.UpdateAnnotationSetRequestFields true Fields to update

Example responses

200 Response

{
  "set": {
    "id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.UpdateAnnotationSetResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Lists annotation types

Code samples

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

r = requests.get('/annotations/v1beta1/types', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/annotations/v1beta1/types", data)
    req.Header = headers

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

GET /annotations/v1beta1/types HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/types',
{
  method: 'GET',

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

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

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

fetch('/annotations/v1beta1/types',
{
  method: 'GET',

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

GET /annotations/v1beta1/types

List all the annotation types from an account.

Parameters

Name In Type Required Description
set_id query string false none
page_size query integer(int32) false A positive number that is the maximum number of results to return.
page_token query string false empty or containing the "next_page_token" from a previous call.
order_by query string false Specifies the result ordering for List requests.
includes query array[string] false Specifies what response metadata should include.

Detailed descriptions

order_by: Specifies the result ordering for List requests.

includes: Specifies what response metadata should include. e.g. when 'INCLUDE_TOTAL_SIZE' is passed, response metadata will include total size of the result.

Enumerated Values

Parameter Value
order_by ORDER_TITLE_UNSPECIFIED
order_by ORDER_TITLE_ASC
order_by ORDER_TITLE_DESC
includes INCLUDE_UNSPECIFIED
includes INCLUDE_TOTAL_SIZE

Example responses

200 Response

{
  "next_page_token": "string",
  "total_size": 0,
  "types": [
    {
      "action_configuration_ids": [
        "string"
      ],
      "id": "string",
      "set_id": "string",
      "title": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.ListAnnotationTypesResponse
default Default An unexpected error response. google.rpc.Status

Creats an annotation type

Code samples

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

r = requests.post('/annotations/v1beta1/types', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/annotations/v1beta1/types", data)
    req.Header = headers

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

POST /annotations/v1beta1/types HTTP/1.1

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

const inputBody = '{
  "set_id": "string",
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/types',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "set_id": "string",
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/types',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /annotations/v1beta1/types

Creates a new annotation type.

Body parameter

{
  "set_id": "string",
  "title": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.annotations.v1beta1.CreateAnnotationTypeRequest true none

Example responses

200 Response

{
  "type": {
    "action_configuration_ids": [
      "string"
    ],
    "id": "string",
    "set_id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.CreateAnnotationTypeResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Returns a single annotation type

Code samples

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

r = requests.get('/annotations/v1beta1/types/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/annotations/v1beta1/types/{id}", data)
    req.Header = headers

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

GET /annotations/v1beta1/types/{id} HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/types/{id}',
{
  method: 'GET',

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

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

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

fetch('/annotations/v1beta1/types/{id}',
{
  method: 'GET',

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

GET /annotations/v1beta1/types/{id}

Returns a single annotation type.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "type": {
    "action_configuration_ids": [
      "string"
    ],
    "id": "string",
    "set_id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.GetAnnotationTypeResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Deletes an annotation type

Code samples

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

r = requests.delete('/annotations/v1beta1/types/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/annotations/v1beta1/types/{id}", data)
    req.Header = headers

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

DELETE /annotations/v1beta1/types/{id} HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/types/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/annotations/v1beta1/types/{id}',
{
  method: 'DELETE',

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

DELETE /annotations/v1beta1/types/{id}

Deletes an annotation type.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.DeleteAnnotationTypeResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Updates an annotation type

Code samples

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

r = requests.patch('/annotations/v1beta1/types/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/annotations/v1beta1/types/{id}", data)
    req.Header = headers

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

PATCH /annotations/v1beta1/types/{id} HTTP/1.1

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

const inputBody = '{
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/types/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/types/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /annotations/v1beta1/types/{id}

Updates an annotation type.

Body parameter

{
  "title": "string"
}

Parameters

Name In Type Required Description
id path string true ID of the annotation set to update
update_mask query array[string] false Optional. The mask to control which fields get updated.
body body mycujoo.annotations.v1beta1.UpdateAnnotationTypeRequestFields true Fields to update

Example responses

200 Response

{
  "type": {
    "action_configuration_ids": [
      "string"
    ],
    "id": "string",
    "set_id": "string",
    "title": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.UpdateAnnotationTypeResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Returns a single annotation

Code samples

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

r = requests.get('/annotations/v1beta1/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/annotations/v1beta1/{id}", data)
    req.Header = headers

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

GET /annotations/v1beta1/{id} HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/{id}',
{
  method: 'GET',

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

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

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

fetch('/annotations/v1beta1/{id}',
{
  method: 'GET',

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

GET /annotations/v1beta1/{id}

Returns a single annotation.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "annotation": {
    "action_call_ids": [
      "string"
    ],
    "create_time": "2019-08-24T14:15:22Z",
    "id": "string",
    "offset": "string",
    "timeline_id": "string",
    "type_id": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.GetAnnotationResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Deletes an annotation

Code samples

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

r = requests.delete('/annotations/v1beta1/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/annotations/v1beta1/{id}", data)
    req.Header = headers

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

DELETE /annotations/v1beta1/{id} HTTP/1.1

Accept: application/json


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

fetch('/annotations/v1beta1/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/annotations/v1beta1/{id}',
{
  method: 'DELETE',

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

DELETE /annotations/v1beta1/{id}

deletes an annotation.

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.DeleteAnnotationResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Updates an annotation

Code samples

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

r = requests.patch('/annotations/v1beta1/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/annotations/v1beta1/{id}", data)
    req.Header = headers

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

PATCH /annotations/v1beta1/{id} HTTP/1.1

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

const inputBody = '{
  "offset": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "offset": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/annotations/v1beta1/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /annotations/v1beta1/{id}

Updates an annotation.

Body parameter

{
  "offset": "string"
}

Parameters

Name In Type Required Description
id path string true ID of the annotation to update
update_mask query array[string] false Optional. The mask to control which fields get updated.
body body mycujoo.annotations.v1beta1.UpdateAnnotationRequestFields true Fields to update

Example responses

200 Response

{
  "annotation": {
    "action_call_ids": [
      "string"
    ],
    "create_time": "2019-08-24T14:15:22Z",
    "id": "string",
    "offset": "string",
    "timeline_id": "string",
    "type_id": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.annotations.v1beta1.UpdateAnnotationResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

AuthService

ChangePassword will change users password

Code samples

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

r = requests.post('/auth/v1beta1/change_password', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/auth/v1beta1/change_password", data)
    req.Header = headers

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

POST /auth/v1beta1/change_password HTTP/1.1

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

const inputBody = '{
  "new_password": "string",
  "old_password": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/auth/v1beta1/change_password',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "new_password": "string",
  "old_password": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/auth/v1beta1/change_password',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /auth/v1beta1/change_password

Body parameter

{
  "new_password": "string",
  "old_password": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.auth.v1beta1.ChangePasswordRequest true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.ChangePasswordResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

CheckPasswordReset is validating reset code

It will check that reset code is still valid and user can proceed with changing password. It generates token that we can use to immediately sign-in user.

Code samples

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

r = requests.post('/auth/v1beta1/check_reset_password', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/auth/v1beta1/check_reset_password", data)
    req.Header = headers

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

POST /auth/v1beta1/check_reset_password HTTP/1.1

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

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

fetch('/auth/v1beta1/check_reset_password',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "reset_code": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/check_reset_password',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /auth/v1beta1/check_reset_password

Body parameter

{
  "reset_code": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.auth.v1beta1.CheckPasswordResetRequest true none

Example responses

200 Response

{
  "token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.CheckPasswordResetResponse
default Default An unexpected error response. google.rpc.Status

AuthService_Login

Code samples

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

r = requests.post('/auth/v1beta1/login', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/auth/v1beta1/login", data)
    req.Header = headers

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

POST /auth/v1beta1/login HTTP/1.1

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

const inputBody = '{
  "email": "string",
  "org_id": "string",
  "password": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/login',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "email": "string",
  "org_id": "string",
  "password": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/login',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /auth/v1beta1/login

Body parameter

{
  "email": "string",
  "org_id": "string",
  "password": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.auth.v1beta1.LoginRequest true none

Example responses

200 Response

{
  "token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.LoginResponse
default Default An unexpected error response. google.rpc.Status

CreateOrganization will create new organization in the system.

It requires information about primary user

Code samples

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

r = requests.post('/auth/v1beta1/organizations', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/auth/v1beta1/organizations", data)
    req.Header = headers

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

POST /auth/v1beta1/organizations HTTP/1.1

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

const inputBody = '{
  "display_name": "string",
  "id": "string",
  "owner": {
    "email": "string",
    "first_name": "string",
    "id": "string",
    "last_name": "string",
    "verified": true
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/organizations',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "display_name": "string",
  "id": "string",
  "owner": {
    "email": "string",
    "first_name": "string",
    "id": "string",
    "last_name": "string",
    "verified": true
  }
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/organizations',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /auth/v1beta1/organizations

Body parameter

{
  "display_name": "string",
  "id": "string",
  "owner": {
    "email": "string",
    "first_name": "string",
    "id": "string",
    "last_name": "string",
    "verified": true
  }
}

Parameters

Name In Type Required Description
body body mycujoo.auth.v1beta1.CreateOrganizationRequest true none

Example responses

200 Response

{
  "organization": {
    "display_name": "string",
    "embed_domains": [
      "string"
    ],
    "has_fairplay_certificate": true,
    "id": "string",
    "is_drm_enabled": true,
    "owner_id": "string",
    "public_key": "string"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.CreateOrganizationResponse
default Default An unexpected error response. google.rpc.Status

GetOrganization will return information about the organization

Code samples

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

r = requests.get('/auth/v1beta1/organizations/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/auth/v1beta1/organizations/{id}", data)
    req.Header = headers

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

GET /auth/v1beta1/organizations/{id} HTTP/1.1

Accept: application/json


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

fetch('/auth/v1beta1/organizations/{id}',
{
  method: 'GET',

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

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

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

fetch('/auth/v1beta1/organizations/{id}',
{
  method: 'GET',

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

GET /auth/v1beta1/organizations/{id}

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "display_name": "string",
  "embed_domains": [
    "string"
  ],
  "has_fairplay_certificate": true,
  "id": "string",
  "is_drm_enabled": true,
  "owner_id": "string",
  "public_key": "string"
}

Responses

Status Meaning Description Schema
200 OK (empty) mycujoo.auth.v1beta1.Organization
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

ResetPassword is used to change user password without old password

from forgot your password page UI.

Code samples

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

r = requests.post('/auth/v1beta1/reset_password', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/auth/v1beta1/reset_password", data)
    req.Header = headers

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

POST /auth/v1beta1/reset_password HTTP/1.1

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

const inputBody = '{
  "new_password": "string",
  "reset_code": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/reset_password',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "new_password": "string",
  "reset_code": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/reset_password',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /auth/v1beta1/reset_password

Body parameter

{
  "new_password": "string",
  "reset_code": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.auth.v1beta1.ResetPasswordRequest true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.ResetPasswordResponse
default Default An unexpected error response. google.rpc.Status

SendPasswordReset is requesting password change

it will send an email to the user with a special link

Code samples

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

r = requests.post('/auth/v1beta1/send_reset_password', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/auth/v1beta1/send_reset_password", data)
    req.Header = headers

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

POST /auth/v1beta1/send_reset_password HTTP/1.1

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

const inputBody = '{
  "email": "string",
  "org_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/send_reset_password',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "email": "string",
  "org_id": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/auth/v1beta1/send_reset_password',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /auth/v1beta1/send_reset_password

Body parameter

{
  "email": "string",
  "org_id": "string"
}
Name In Type Required Description
body body mycujoo.auth.v1beta1.SendPasswordResetRequest true none

Example responses

200 Response

{}
Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.SendPasswordResetResponse
default Default An unexpected error response. google.rpc.Status

GetUser is returning private user information which is used for editing user profile

this endpoint is protected by authentication

Code samples

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

r = requests.get('/auth/v1beta1/users/{user_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/auth/v1beta1/users/{user_id}", data)
    req.Header = headers

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

GET /auth/v1beta1/users/{user_id} HTTP/1.1

Accept: application/json


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

fetch('/auth/v1beta1/users/{user_id}',
{
  method: 'GET',

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

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

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

fetch('/auth/v1beta1/users/{user_id}',
{
  method: 'GET',

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

GET /auth/v1beta1/users/{user_id}

In order to request information about currently logged in user you can use value myself for the user_id

Parameters

Name In Type Required Description
user_id path string true none

Example responses

200 Response

{
  "email": "string",
  "first_name": "string",
  "id": "string",
  "last_name": "string",
  "verified": true
}

Responses

Status Meaning Description Schema
200 OK (empty) mycujoo.auth.v1beta1.User
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

UpdateUser will update user profile

Code samples

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

r = requests.patch('/auth/v1beta1/users/{user_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/auth/v1beta1/users/{user_id}", data)
    req.Header = headers

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

PATCH /auth/v1beta1/users/{user_id} HTTP/1.1

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

const inputBody = '{
  "first_name": "string",
  "last_name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/auth/v1beta1/users/{user_id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "first_name": "string",
  "last_name": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/auth/v1beta1/users/{user_id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /auth/v1beta1/users/{user_id}

Body parameter

{
  "first_name": "string",
  "last_name": "string"
}

Parameters

Name In Type Required Description
user_id path string true none
update_mask query array[string] false none
body body mycujoo.auth.v1beta1.UserUpdate true none

Example responses

200 Response

{
  "user": {
    "email": "string",
    "first_name": "string",
    "id": "string",
    "last_name": "string",
    "verified": true
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.auth.v1beta1.UpdateUserResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

EventsService

Lists all the events

Code samples

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

r = requests.get('/bff/events/v1beta1', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/bff/events/v1beta1", data)
    req.Header = headers

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

GET /bff/events/v1beta1 HTTP/1.1

Accept: application/json


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

fetch('/bff/events/v1beta1',
{
  method: 'GET',

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

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

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

fetch('/bff/events/v1beta1',
{
  method: 'GET',

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

GET /bff/events/v1beta1

By passing in the appropriate options, you can search for available events in the system

Parameters

Name In Type Required Description
order_by query string false Specifies the result ordering for List requests.
page_size query integer(int32) false Maximum number of records to return.
page_token query string false The pagination token in the List request.
status query array[string] false Filter results by event status.

Detailed descriptions

order_by: Specifies the result ordering for List requests.

status: Filter results by event status.

Enumerated Values

Parameter Value
order_by ORDER_UNSPECIFIED
order_by ORDER_START_TIME_ASC
order_by ORDER_START_TIME_DESC
order_by ORDER_TITLE_ASC
order_by ORDER_TITLE_DESC
status EVENT_STATUS_UNSPECIFIED
status EVENT_STATUS_SCHEDULED
status EVENT_STATUS_RESCHEDULED
status EVENT_STATUS_CANCELLED
status EVENT_STATUS_POSTPONED
status EVENT_STATUS_DELAYED
status EVENT_STATUS_STARTED
status EVENT_STATUS_PAUSED
status EVENT_STATUS_SUSPENDED
status EVENT_STATUS_FINISHED

Example responses

200 Response

{
  "events": [
    {
      "id": "ck9poahb1000601laar5w4dfd",
      "title": "2020 MyCujoo Champions League Final"
    }
  ],
  "next_page_token": "string",
  "previous_page_token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.bff.v1beta1.ListResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Gets event by ID

Code samples

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

r = requests.get('/bff/events/v1beta1/{id}', headers = headers)

print(r.json())

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

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

GET /bff/events/v1beta1/{id} HTTP/1.1

Accept: application/json


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

fetch('/bff/events/v1beta1/{id}',
{
  method: 'GET',

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

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

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

fetch('/bff/events/v1beta1/{id}',
{
  method: 'GET',

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

GET /bff/events/v1beta1/{id}

Parameters

Name In Type Required Description
id path string true ID of the event to retrieve

Example responses

200 Response

{
  "id": "ck9poahb1000601laar5w4dfd",
  "title": "2020 MyCujoo Champions League Final"
}

Responses

Status Meaning Description Schema
200 OK If found it will contain event mycujoo.bff.v1beta1.Event
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

OrgService

Get a list of allowed embed domains

Code samples

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

r = requests.get('/bff/org/v1beta1/embed_domains', headers = headers)

print(r.json())

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", "/bff/org/v1beta1/embed_domains", data)
    req.Header = headers

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

GET /bff/org/v1beta1/embed_domains HTTP/1.1

Accept: application/json


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

fetch('/bff/org/v1beta1/embed_domains',
{
  method: 'GET',

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

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

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

fetch('/bff/org/v1beta1/embed_domains',
{
  method: 'GET',

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

GET /bff/org/v1beta1/embed_domains

Example responses

200 Response

{
  "domains": [
    "string"
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.bff.v1beta1.GetOrganizationEmbedDomainsResponse
default Default An unexpected error response. google.rpc.Status

TimelineService

Gets timeline by ID

Code samples

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

r = requests.get('/bff/timeline/v1beta1/{id}', headers = headers)

print(r.json())

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

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

GET /bff/timeline/v1beta1/{id} HTTP/1.1

Accept: application/json


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

fetch('/bff/timeline/v1beta1/{id}',
{
  method: 'GET',

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

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

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

fetch('/bff/timeline/v1beta1/{id}',
{
  method: 'GET',

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

GET /bff/timeline/v1beta1/{id}

Parameters

Name In Type Required Description
id path string true ID of the timeline to retrieve

Example responses

200 Response

{
  "actions": [
    {
      "data": {
        "color": "#ffffff",
        "label": "Kickoff"
      },
      "id": "ck9poahb1000601laar5w4dfd",
      "offset": 120000,
      "type": "show_timeline_marker"
    }
  ],
  "update_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.bff.v1beta1.GetTimelineResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

EntitlementsService

ListEntitlements returns list of user and content id pairs that match specified filters

Code samples

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

r = requests.get('/entitlements/v1beta1', headers = headers)

print(r.json())

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", "/entitlements/v1beta1", data)
    req.Header = headers

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

GET /entitlements/v1beta1 HTTP/1.1

Accept: application/json


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

fetch('/entitlements/v1beta1',
{
  method: 'GET',

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

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

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

fetch('/entitlements/v1beta1',
{
  method: 'GET',

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

GET /entitlements/v1beta1

Parameters

Name In Type Required Description
page_size query integer(int32) false Maximum number of records to return.
page_token query string false The pagination token in the list request.
subject_id query string false Filters entitlements by subject id.
content_id query string false Filters entitlements by content id.

Example responses

200 Response

{
  "entitlements": [
    {
      "content_id": "string",
      "subject_id": "string"
    }
  ],
  "next_page_token": "string",
  "previous_page_token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.entitlements.v1beta1.ListEntitlementsResponse
default Default An unexpected error response. google.rpc.Status

CreateEntitlement stores entitlement in the service

Code samples

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

r = requests.post('/entitlements/v1beta1', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /entitlements/v1beta1 HTTP/1.1

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

const inputBody = '{
  "content_id": "string",
  "subject_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/entitlements/v1beta1',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "content_id": "string",
  "subject_id": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/entitlements/v1beta1',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /entitlements/v1beta1

Body parameter

{
  "content_id": "string",
  "subject_id": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.entitlements.v1beta1.CreateEntitlementRequest true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.entitlements.v1beta1.CreateEntitlementResponse
default Default An unexpected error response. google.rpc.Status

DeleteEntitlement removes entitlement from the service

Code samples

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

r = requests.delete('/entitlements/v1beta1', headers = headers)

print(r.json())

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("DELETE", "/entitlements/v1beta1", data)
    req.Header = headers

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

DELETE /entitlements/v1beta1 HTTP/1.1

Accept: application/json


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

fetch('/entitlements/v1beta1',
{
  method: 'DELETE',

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

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

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

fetch('/entitlements/v1beta1',
{
  method: 'DELETE',

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

DELETE /entitlements/v1beta1

Parameters

Name In Type Required Description
subject_id query string false ID of the subject.
content_id query string false ID of the content.

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.entitlements.v1beta1.DeleteEntitlementResponse
default Default An unexpected error response. google.rpc.Status

CheckEntitlement returns boolean to indicate if user has access to specific content

Code samples

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

r = requests.get('/entitlements/v1beta1/check', headers = headers)

print(r.json())

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", "/entitlements/v1beta1/check", data)
    req.Header = headers

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

GET /entitlements/v1beta1/check HTTP/1.1

Accept: application/json


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

fetch('/entitlements/v1beta1/check',
{
  method: 'GET',

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

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

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

fetch('/entitlements/v1beta1/check',
{
  method: 'GET',

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

GET /entitlements/v1beta1/check

Parameters

Name In Type Required Description
subject_id query string false ID of the subject.
content_id query string false ID of the content.

Example responses

200 Response

{
  "entitled": true
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.entitlements.v1beta1.CheckEntitlementResponse
default Default An unexpected error response. google.rpc.Status

EventService

Gets all the events for a specific account

Code samples

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

r = requests.get('/events/v1beta2', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

GET /events/v1beta2 HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2',
{
  method: 'GET',

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

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

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

fetch('/events/v1beta2',
{
  method: 'GET',

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

GET /events/v1beta2

By passing in the appropriate options, you can search for available events in the system

Parameters

Name In Type Required Description
order_by query string false Specifies the result ordering for List requests.
page_size query integer(int32) false Maximum number of records to return.
page_token query string false The pagination token in the List request.
status query array[string] false Filter results by event status.
includes query array[string] false Specifies what response metadata should include.
stream_ids query array[string] false Filter results by events that contain specified stream ids.

Detailed descriptions

order_by: Specifies the result ordering for List requests.

status: Filter results by event status.

includes: Specifies what response metadata should include. e.g. when 'INCLUDE_TOTAL_SIZE' is passed, response metadata will include total size of the result.

Enumerated Values

Parameter Value
order_by ORDER_UNSPECIFIED
order_by ORDER_DATE_ASC
order_by ORDER_DATE_DESC
status EVENT_STATUS_UNSPECIFIED
status EVENT_STATUS_SCHEDULED
status EVENT_STATUS_RESCHEDULED
status EVENT_STATUS_CANCELLED
status EVENT_STATUS_POSTPONED
status EVENT_STATUS_DELAYED
status EVENT_STATUS_STARTED
status EVENT_STATUS_PAUSED
status EVENT_STATUS_SUSPENDED
status EVENT_STATUS_FINISHED
includes INCLUDE_UNSPECIFIED
includes INCLUDE_TOTAL_SIZE

Example responses

200 Response

{
  "events": [
    {
      "id": "ck9poahb1000601laar5w4dfd",
      "title": "2020 MyCujoo Champions League Final"
    }
  ],
  "metadata": {
    "next_page_token": "string",
    "previous_page_token": "string",
    "total_size": 0
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.ListResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Adds an event

Code samples

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

r = requests.post('/events/v1beta2', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

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

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

POST /events/v1beta2 HTTP/1.1

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

const inputBody = '{
  "description": "string",
  "is_test": true,
  "location": {
    "online": "string",
    "physical": {
      "city": "Amsterdam",
      "continent_code": "EU",
      "country_code": "NL",
      "venue": "Johan Cruijff ArenA"
    }
  },
  "metadata": {
    "data": {},
    "schema_id": "string"
  },
  "organiser": "string",
  "poster_url": "string",
  "start_time": "2019-08-24T14:15:22Z",
  "thumbnail_url": "string",
  "timezone": "string",
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/events/v1beta2',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "description": "string",
  "is_test": true,
  "location": {
    "online": "string",
    "physical": {
      "city": "Amsterdam",
      "continent_code": "EU",
      "country_code": "NL",
      "venue": "Johan Cruijff ArenA"
    }
  },
  "metadata": {
    "data": {},
    "schema_id": "string"
  },
  "organiser": "string",
  "poster_url": "string",
  "start_time": "2019-08-24T14:15:22Z",
  "thumbnail_url": "string",
  "timezone": "string",
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/events/v1beta2',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /events/v1beta2

Adds an event to the system

Body parameter

{
  "description": "string",
  "is_test": true,
  "location": {
    "online": "string",
    "physical": {
      "city": "Amsterdam",
      "continent_code": "EU",
      "country_code": "NL",
      "venue": "Johan Cruijff ArenA"
    }
  },
  "metadata": {
    "data": {},
    "schema_id": "string"
  },
  "organiser": "string",
  "poster_url": "string",
  "start_time": "2019-08-24T14:15:22Z",
  "thumbnail_url": "string",
  "timezone": "string",
  "title": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.events.v1beta2.CreateRequest true none

Example responses

200 Response

{
  "event": {
    "id": "ck9poahb1000601laar5w4dfd",
    "title": "2020 MyCujoo Champions League Final"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.CreateResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Adds stream to an event

Code samples

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

r = requests.post('/events/v1beta2/{event_id}/stream/{stream_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/events/v1beta2/{event_id}/stream/{stream_id}", data)
    req.Header = headers

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

POST /events/v1beta2/{event_id}/stream/{stream_id} HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2/{event_id}/stream/{stream_id}',
{
  method: 'POST',

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

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

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

fetch('/events/v1beta2/{event_id}/stream/{stream_id}',
{
  method: 'POST',

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

POST /events/v1beta2/{event_id}/stream/{stream_id}

Parameters

Name In Type Required Description
event_id path string true none
stream_id path string true none

Example responses

200 Response

{
  "event_id": "string",
  "stream_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.AddStreamResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Removes stream to an event

Code samples

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

r = requests.delete('/events/v1beta2/{event_id}/stream/{stream_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/events/v1beta2/{event_id}/stream/{stream_id}", data)
    req.Header = headers

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

DELETE /events/v1beta2/{event_id}/stream/{stream_id} HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2/{event_id}/stream/{stream_id}',
{
  method: 'DELETE',

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

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

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

fetch('/events/v1beta2/{event_id}/stream/{stream_id}',
{
  method: 'DELETE',

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

DELETE /events/v1beta2/{event_id}/stream/{stream_id}

Parameters

Name In Type Required Description
event_id path string true none
stream_id path string true none

Example responses

200 Response

{
  "event_id": "string",
  "stream_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.RemoveStreamResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Adds timeline to an event

Code samples

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

r = requests.post('/events/v1beta2/{event_id}/timeline/{timeline_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/events/v1beta2/{event_id}/timeline/{timeline_id}", data)
    req.Header = headers

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

POST /events/v1beta2/{event_id}/timeline/{timeline_id} HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2/{event_id}/timeline/{timeline_id}',
{
  method: 'POST',

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

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

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

fetch('/events/v1beta2/{event_id}/timeline/{timeline_id}',
{
  method: 'POST',

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

POST /events/v1beta2/{event_id}/timeline/{timeline_id}

Parameters

Name In Type Required Description
event_id path string true none
timeline_id path string true none

Example responses

200 Response

{
  "event_id": "string",
  "timeline_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.AddTimelineResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Removes timeline to an event

Code samples

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

r = requests.delete('/events/v1beta2/{event_id}/timeline/{timeline_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/events/v1beta2/{event_id}/timeline/{timeline_id}", data)
    req.Header = headers

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

DELETE /events/v1beta2/{event_id}/timeline/{timeline_id} HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2/{event_id}/timeline/{timeline_id}',
{
  method: 'DELETE',

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

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

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

fetch('/events/v1beta2/{event_id}/timeline/{timeline_id}',
{
  method: 'DELETE',

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

DELETE /events/v1beta2/{event_id}/timeline/{timeline_id}

Parameters

Name In Type Required Description
event_id path string true none
timeline_id path string true none

Example responses

200 Response

{
  "event_id": "string",
  "timeline_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.RemoveTimelineResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Gets event for a specific account by ID

Code samples

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

r = requests.get('/events/v1beta2/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/events/v1beta2/{id}", data)
    req.Header = headers

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

GET /events/v1beta2/{id} HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2/{id}',
{
  method: 'GET',

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

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

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

fetch('/events/v1beta2/{id}',
{
  method: 'GET',

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

GET /events/v1beta2/{id}

Parameters

Name In Type Required Description
id path string true ID of the event to retrieve

Example responses

200 Response

{
  "event": {
    "id": "ck9poahb1000601laar5w4dfd",
    "title": "2020 MyCujoo Champions League Final"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.GetResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Deletes event for a specific account

Code samples

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

r = requests.delete('/events/v1beta2/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/events/v1beta2/{id}", data)
    req.Header = headers

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

DELETE /events/v1beta2/{id} HTTP/1.1

Accept: application/json


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

fetch('/events/v1beta2/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/events/v1beta2/{id}',
{
  method: 'DELETE',

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

DELETE /events/v1beta2/{id}

Parameters

Name In Type Required Description
id path string true Resource ID that should be deleted

Example responses

200 Response

{
  "id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.DeleteResponse
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

Updates an event

Code samples

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

r = requests.patch('/events/v1beta2/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/events/v1beta2/{id}", data)
    req.Header = headers

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

PATCH /events/v1beta2/{id} HTTP/1.1

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

const inputBody = '{
  "description": "string",
  "is_test": true,
  "location": {
    "online": "string",
    "physical": {
      "city": "Amsterdam",
      "continent_code": "EU",
      "country_code": "NL",
      "venue": "Johan Cruijff ArenA"
    }
  },
  "metadata": {
    "data": {},
    "schema_id": "string"
  },
  "organiser": "string",
  "poster_url": "string",
  "start_time": "2019-08-24T14:15:22Z",
  "status": "EVENT_STATUS_UNSPECIFIED",
  "thumbnail_url": "string",
  "timezone": "string",
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/events/v1beta2/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "description": "string",
  "is_test": true,
  "location": {
    "online": "string",
    "physical": {
      "city": "Amsterdam",
      "continent_code": "EU",
      "country_code": "NL",
      "venue": "Johan Cruijff ArenA"
    }
  },
  "metadata": {
    "data": {},
    "schema_id": "string"
  },
  "organiser": "string",
  "poster_url": "string",
  "start_time": "2019-08-24T14:15:22Z",
  "status": "EVENT_STATUS_UNSPECIFIED",
  "thumbnail_url": "string",
  "timezone": "string",
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/events/v1beta2/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /events/v1beta2/{id}

Updates an event in the system

Body parameter

{
  "description": "string",
  "is_test": true,
  "location": {
    "online": "string",
    "physical": {
      "city": "Amsterdam",
      "continent_code": "EU",
      "country_code": "NL",
      "venue": "Johan Cruijff ArenA"
    }
  },
  "metadata": {
    "data": {},
    "schema_id": "string"
  },
  "organiser": "string",
  "poster_url": "string",
  "start_time": "2019-08-24T14:15:22Z",
  "status": "EVENT_STATUS_UNSPECIFIED",
  "thumbnail_url": "string",
  "timezone": "string",
  "title": "string"
}

Parameters

Name In Type Required Description
id path string true ID of the event
update_mask query array[string] false Optional. The mask to control which fields get updated.
body body mycujoo.events.v1beta2.UpdateRequestFields true Fields to update

Example responses

200 Response

{
  "event": {
    "id": "ck9poahb1000601laar5w4dfd",
    "title": "2020 MyCujoo Champions League Final"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.events.v1beta2.UpdateResponse
400 Bad Request Bad input parameters Inline
500 Internal Server Error Internal Server Error Inline
default Default An unexpected error response. google.rpc.Status

Response Schema

UploadVOD

Creates a TUS upload request

Code samples

import requests
headers = {
  'Content-Type': 'application/json',
  'Tus-Resumable': '1.0.0',
  'Authorization': 'bearer xxxxxxx',
  'Upload-Length': 'string',
  'Upload-Metadata': 'string'
}

r = requests.post('/files/', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Tus-Resumable": []string{"1.0.0"},
        "Authorization": []string{"bearer xxxxxxx"},
        "Upload-Length": []string{"string"},
        "Upload-Metadata": []string{"string"},
    }

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

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

POST /files/ HTTP/1.1

Content-Type: application/json

Tus-Resumable: 1.0.0
Authorization: bearer xxxxxxx
Upload-Length: string
Upload-Metadata: string

const inputBody = '{
  "id": "ck8u9fwwu1wtg0hewiqz3we6j",
  "metadata": {
    "key": "string",
    "value": "string"
  },
  "streamId": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Tus-Resumable':'1.0.0',
  'Authorization':'bearer xxxxxxx',
  'Upload-Length':'string',
  'Upload-Metadata':'string'
};

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

const fetch = require('node-fetch');
const inputBody = {
  "id": "ck8u9fwwu1wtg0hewiqz3we6j",
  "metadata": {
    "key": "string",
    "value": "string"
  },
  "streamId": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Tus-Resumable':'1.0.0',
  'Authorization':'bearer xxxxxxx',
  'Upload-Length':'string',
  'Upload-Metadata':'string'
};

fetch('/files/',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /files/

Creates a TUS upload request

Body parameter

{
  "id": "ck8u9fwwu1wtg0hewiqz3we6j",
  "metadata": {
    "key": "string",
    "value": "string"
  },
  "streamId": "string"
}

Parameters

Name In Type Required Description
Tus-Resumable header string true none
Authorization header string true none
Upload-Length header string true The total size in bytes of the upload
Upload-Metadata header string true MUST consist of one or more comma-separated key-value pairs. Values MUST be base64 encode. Example: filename dGVzdC50eHQ=,content-type dGV4dC9wbGFpbg==
body body UploadRequest false Upload request to perform

Detailed descriptions

Upload-Metadata: MUST consist of one or more comma-separated key-value pairs. Values MUST be base64 encode. Example: filename dGVzdC50eHQ=,content-type dGV4dC9wbGFpbg==

Responses

Status Meaning Description Schema
201 Created Upload request created None
400 Bad Request bad input parameter None

Response Headers

Status Header Type Format Description
201 Location string url Temporary URL for this upload. Example: https://mls.mycujoo.tv/api/streaming/files/ck8u9fwwu1wtg0hewiqz3we6j
201 Tus-Resumable string none

Gets the current state of an upload

Code samples

import requests
headers = {
  'Tus-Resumable': '1.0.0'
}

r = requests.head('/files/{uploadId}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Tus-Resumable": []string{"1.0.0"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("HEAD", "/files/{uploadId}", data)
    req.Header = headers

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

HEAD /files/{uploadId} HTTP/1.1

Tus-Resumable: 1.0.0


const headers = {
  'Tus-Resumable':'1.0.0'
};

fetch('/files/{uploadId}',
{
  method: 'HEAD',

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

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

const headers = {
  'Tus-Resumable':'1.0.0'
};

fetch('/files/{uploadId}',
{
  method: 'HEAD',

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

HEAD /files/{uploadId}

Gets the current state of an upload

Parameters

Name In Type Required Description
uploadId path string true The unique uploadId to upload data to (returned by POST /files)
Tus-Resumable header string true none

Detailed descriptions

uploadId: The unique uploadId to upload data to (returned by POST /files)

Responses

Status Meaning Description Schema
200 OK Upload information returned None

Response Headers

Status Header Type Format Description
200 Tus-Resumable string none
200 Upload-Length integer The total size in bytes of the upload
200 Upload-Offset integer The new offset if the upload was a partial upload

Uploads data to an existing upload

Code samples

import requests
headers = {
  'Content-Type': 'application/offset+octet-stream',
  'Upload-Offset': '0',
  'Content-Length': '0',
  'Tus-Resumable': '1.0.0'
}

r = requests.patch('/files/{uploadId}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/offset+octet-stream"},
        "Upload-Offset": []string{"0"},
        "Content-Length": []string{"0"},
        "Tus-Resumable": []string{"1.0.0"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/files/{uploadId}", data)
    req.Header = headers

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

PATCH /files/{uploadId} HTTP/1.1

Content-Type: application/offset+octet-stream
Upload-Offset: 0
Content-Length: 0
Tus-Resumable: 1.0.0


const headers = {
  'Content-Type':'application/offset+octet-stream',
  'Upload-Offset':'0',
  'Content-Length':'0',
  'Tus-Resumable':'1.0.0'
};

fetch('/files/{uploadId}',
{
  method: 'PATCH',

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

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

const headers = {
  'Content-Type':'application/offset+octet-stream',
  'Upload-Offset':'0',
  'Content-Length':'0',
  'Tus-Resumable':'1.0.0'
};

fetch('/files/{uploadId}',
{
  method: 'PATCH',

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

PATCH /files/{uploadId}

Uploads data to an existing upload

Parameters

Name In Type Required Description
uploadId path string true The unique uploadId to upload data to (returned by POST /files/)
Content-Type header string true none
Upload-Offset header integer true The Upload-Offset request and response header indicates a byte offset within a resource.
Content-Length header integer true none
Tus-Resumable header string true none

Detailed descriptions

uploadId: The unique uploadId to upload data to (returned by POST /files/)

Upload-Offset: The Upload-Offset request and response header indicates a byte offset within a resource.

Responses

Status Meaning Description Schema
201 Created Upload request created None

Response Headers

Status Header Type Format Description
201 Location string url Final URL of the upload, only sent when upload is finished.
201 Tus-Resumable string none
201 Upload-Offset integer The new offset if the upload was a partial upload

GeofenceService

Create stores geoblocking settings against specified subject_id

Code samples

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

r = requests.post('/geofence/v1beta1', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /geofence/v1beta1 HTTP/1.1

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

const inputBody = '{
  "geoblocking": {
    "allow": {
      "country_codes": [
        "string"
      ]
    },
    "disallow": {
      "country_codes": [
        "string"
      ]
    }
  },
  "subject_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/geofence/v1beta1',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "geoblocking": {
    "allow": {
      "country_codes": [
        "string"
      ]
    },
    "disallow": {
      "country_codes": [
        "string"
      ]
    }
  },
  "subject_id": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/geofence/v1beta1',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /geofence/v1beta1

Body parameter

{
  "geoblocking": {
    "allow": {
      "country_codes": [
        "string"
      ]
    },
    "disallow": {
      "country_codes": [
        "string"
      ]
    }
  },
  "subject_id": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.geofence.v1beta1.CreateRequest true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.geofence.v1beta1.CreateResponse
default Default An unexpected error response. google.rpc.Status

Get returns geoblocking settings for specified subject_id

Code samples

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

r = requests.get('/geofence/v1beta1/{subject_id}', headers = headers)

print(r.json())

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", "/geofence/v1beta1/{subject_id}", data)
    req.Header = headers

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

GET /geofence/v1beta1/{subject_id} HTTP/1.1

Accept: application/json


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

fetch('/geofence/v1beta1/{subject_id}',
{
  method: 'GET',

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

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

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

fetch('/geofence/v1beta1/{subject_id}',
{
  method: 'GET',

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

GET /geofence/v1beta1/{subject_id}

Parameters

Name In Type Required Description
subject_id path string true ID of the subject

Example responses

200 Response

{
  "allow": {
    "country_codes": [
      "string"
    ]
  },
  "disallow": {
    "country_codes": [
      "string"
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK Information about geoblocking for the subject mycujoo.geofence.v1beta1.Geoblocking
default Default An unexpected error response. google.rpc.Status

Delete removes geoblocking settings from specified subject_id

Code samples

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

r = requests.delete('/geofence/v1beta1/{subject_id}', headers = headers)

print(r.json())

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("DELETE", "/geofence/v1beta1/{subject_id}", data)
    req.Header = headers

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

DELETE /geofence/v1beta1/{subject_id} HTTP/1.1

Accept: application/json


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

fetch('/geofence/v1beta1/{subject_id}',
{
  method: 'DELETE',

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

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

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

fetch('/geofence/v1beta1/{subject_id}',
{
  method: 'DELETE',

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

DELETE /geofence/v1beta1/{subject_id}

Parameters

Name In Type Required Description
subject_id path string true ID of the subject

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.geofence.v1beta1.DeleteResponse
default Default An unexpected error response. google.rpc.Status

Update updates geoblocking settings against specified subject_id

Code samples

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

r = requests.patch('/geofence/v1beta1/{subject_id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/geofence/v1beta1/{subject_id}", data)
    req.Header = headers

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

PATCH /geofence/v1beta1/{subject_id} HTTP/1.1

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

const inputBody = '{
  "allow": {
    "country_codes": [
      "string"
    ]
  },
  "disallow": {
    "country_codes": [
      "string"
    ]
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/geofence/v1beta1/{subject_id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "allow": {
    "country_codes": [
      "string"
    ]
  },
  "disallow": {
    "country_codes": [
      "string"
    ]
  }
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/geofence/v1beta1/{subject_id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /geofence/v1beta1/{subject_id}

Body parameter

{
  "allow": {
    "country_codes": [
      "string"
    ]
  },
  "disallow": {
    "country_codes": [
      "string"
    ]
  }
}

Parameters

Name In Type Required Description
subject_id path string true ID of the subject
body body mycujoo.geofence.v1beta1.Geoblocking true Information about geoblocking for the subject

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.geofence.v1beta1.UpdateResponse
default Default An unexpected error response. google.rpc.Status

internal

GetRaw returns geoblocking settings for specified subject_id with org information

It would be used by CF worker as fallback if Cloudflare KV store does not work Uses internal auth

Code samples

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

r = requests.get('/geofence/v1beta1/{subject_id}/raw', headers = headers)

print(r.json())

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", "/geofence/v1beta1/{subject_id}/raw", data)
    req.Header = headers

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

GET /geofence/v1beta1/{subject_id}/raw HTTP/1.1

Accept: application/json


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

fetch('/geofence/v1beta1/{subject_id}/raw',
{
  method: 'GET',

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

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

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

fetch('/geofence/v1beta1/{subject_id}/raw',
{
  method: 'GET',

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

GET /geofence/v1beta1/{subject_id}/raw

Parameters

Name In Type Required Description
subject_id path string true ID of the subject

Example responses

200 Response

{
  "geoblocking": {
    "allow": {
      "country_codes": [
        "string"
      ]
    },
    "disallow": {
      "country_codes": [
        "string"
      ]
    }
  },
  "org_id": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.geofence.v1beta1.GetRawResponse
default Default An unexpected error response. google.rpc.Status

MetadataService

Adds data to the system

Code samples

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

r = requests.post('/metadata/v1beta1/data', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /metadata/v1beta1/data HTTP/1.1

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

const inputBody = '{
  "data": {
    "competitionName": {
      "string": "Champions League"
    },
    "team": {
      "name": "Legia Warsaw",
      "players": [
        "Marek Saganowski"
      ]
    },
    "title": "Final 2020"
  },
  "schema_id": "1do8zuDeZKfh2YSgzd2ek69jhOY"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

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

const fetch = require('node-fetch');
const inputBody = {
  "data": {
    "competitionName": {
      "string": "Champions League"
    },
    "team": {
      "name": "Legia Warsaw",
      "players": [
        "Marek Saganowski"
      ]
    },
    "title": "Final 2020"
  },
  "schema_id": "1do8zuDeZKfh2YSgzd2ek69jhOY"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/metadata/v1beta1/data',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /metadata/v1beta1/data

This method allows you to store data in the system after is successfully validated against provided schema id

Body parameter

{
  "data": {
    "competitionName": {
      "string": "Champions League"
    },
    "team": {
      "name": "Legia Warsaw",
      "players": [
        "Marek Saganowski"
      ]
    },
    "title": "Final 2020"
  },
  "schema_id": "1do8zuDeZKfh2YSgzd2ek69jhOY"
}

Parameters

Name In Type Required Description
body body mycujoo.metadata.v1beta1.CreateDataRequest true none

Example responses

200 Response

{
  "data": {
    "competitionName": {
      "string": "Champions League"
    },
    "team": {
      "name": "Legia Warsaw",
      "players": [
        "Marek Saganowski"
      ]
    },
    "title": "Final 2020"
  },
  "id": "ck9be30x30lnk1cmsengq2tq2"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.CreateDataResponse
default Default An unexpected error response. google.rpc.Status

Gets data from the system by specified id

Code samples

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

r = requests.get('/metadata/v1beta1/data/{id}', headers = headers)

print(r.json())

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

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

GET /metadata/v1beta1/data/{id} HTTP/1.1

Accept: application/json


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

fetch('/metadata/v1beta1/data/{id}',
{
  method: 'GET',

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

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

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

fetch('/metadata/v1beta1/data/{id}',
{
  method: 'GET',

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

GET /metadata/v1beta1/data/{id}

Returns data that matches specified id

Parameters

Name In Type Required Description
id path string true ID of the data

Example responses

200 Response

{
  "data": {
    "competitionName": {
      "string": "Champions League"
    },
    "team": {
      "name": "Legia Warsaw",
      "players": [
        "Marek Saganowski"
      ]
    },
    "title": "Final 2020"
  },
  "schema_id": "1do8zuDeZKfh2YSgzd2ek69jhOY"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.GetDataResponse
default Default An unexpected error response. google.rpc.Status

Removes data from the system

Code samples

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

r = requests.delete('/metadata/v1beta1/data/{id}', headers = headers)

print(r.json())

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

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

DELETE /metadata/v1beta1/data/{id} HTTP/1.1

Accept: application/json


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

fetch('/metadata/v1beta1/data/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/metadata/v1beta1/data/{id}',
{
  method: 'DELETE',

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

DELETE /metadata/v1beta1/data/{id}

Removes data that matches specified id

Parameters

Name In Type Required Description
id path string true ID of data to delete

Example responses

200 Response

{
  "id": "ck9be30x30lnk1cmsengq2tq2"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.DeleteDataResponse
default Default An unexpected error response. google.rpc.Status

Updates data in the system

Code samples

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

r = requests.patch('/metadata/v1beta1/data/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/metadata/v1beta1/data/{id}", data)
    req.Header = headers

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

PATCH /metadata/v1beta1/data/{id} HTTP/1.1

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

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

fetch('/metadata/v1beta1/data/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "data": {},
  "schema_id": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/metadata/v1beta1/data/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /metadata/v1beta1/data/{id}

Updates data that is stored in the system by specified id

Body parameter

{
  "data": {},
  "schema_id": "string"
}

Parameters

Name In Type Required Description
id path string true ID of the data
body body mycujoo.metadata.v1beta1.UpdateDataRequest.UpdateFields true none

Example responses

200 Response

{
  "data": {
    "competitionName": {
      "string": "Champions League"
    },
    "team": {
      "name": "Legia Warsaw",
      "players": [
        "Marek Saganowski"
      ]
    },
    "title": "Final 2020"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.UpdateDataResponse
default Default An unexpected error response. google.rpc.Status

Gets all the schemas for a specific organization

Code samples

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

r = requests.get('/metadata/v1beta1/schemas', headers = headers)

print(r.json())

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", "/metadata/v1beta1/schemas", data)
    req.Header = headers

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

GET /metadata/v1beta1/schemas HTTP/1.1

Accept: application/json


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

fetch('/metadata/v1beta1/schemas',
{
  method: 'GET',

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

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

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

fetch('/metadata/v1beta1/schemas',
{
  method: 'GET',

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

GET /metadata/v1beta1/schemas

Lists all the schemas that are owned by specific organization.

Parameters

Name In Type Required Description
order_by query string false Specifies the result ordering for List requests.
page_size query integer(int32) false Maximum number of records to return. Defaults to 100.
page_token query string false The pagination token in the List request.
category query string false Category to filter by.

Detailed descriptions

order_by: Specifies the result ordering for List requests.

Enumerated Values

Parameter Value
order_by ORDER_UNSPECIFIED
order_by ORDER_CREATED_AT_ASC
order_by ORDER_CREATED_AT_DESC
order_by ORDER_ALPHABETICAL_ASC
order_by ORDER_ALPHABETICAL_DESC

Example responses

200 Response

{
  "schemas": [
    {
      "id": "1do8zuDeZKfh2YSgzd2ek69jhOY",
      "title": "test schema"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.ListSchemasResponse
default Default An unexpected error response. google.rpc.Status

Adds schema to the system

Code samples

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

r = requests.post('/metadata/v1beta1/schemas', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/metadata/v1beta1/schemas", data)
    req.Header = headers

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

POST /metadata/v1beta1/schemas HTTP/1.1

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

const inputBody = '{
  "fields": [
    {
      "name": "title",
      "type": "string"
    },
    {
      "name": "competitionName",
      "type": [
        "null",
        "string"
      ]
    },
    {
      "name": "team",
      "type": {
        "fields": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "players",
            "type": {
              "default": [],
              "items": "string",
              "type": "array"
            }
          }
        ],
        "name": "recordTeam",
        "type": "record"
      }
    }
  ],
  "title": "test schema"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/metadata/v1beta1/schemas',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "fields": [
    {
      "name": "title",
      "type": "string"
    },
    {
      "name": "competitionName",
      "type": [
        "null",
        "string"
      ]
    },
    {
      "name": "team",
      "type": {
        "fields": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "players",
            "type": {
              "default": [],
              "items": "string",
              "type": "array"
            }
          }
        ],
        "name": "recordTeam",
        "type": "record"
      }
    }
  ],
  "title": "test schema"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/metadata/v1beta1/schemas',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /metadata/v1beta1/schemas

This method allows you to store schema in the system. This schema needs to contain title and valid AVRO fields.

Body parameter

{
  "fields": [
    {
      "name": "title",
      "type": "string"
    },
    {
      "name": "competitionName",
      "type": [
        "null",
        "string"
      ]
    },
    {
      "name": "team",
      "type": {
        "fields": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "players",
            "type": {
              "default": [],
              "items": "string",
              "type": "array"
            }
          }
        ],
        "name": "recordTeam",
        "type": "record"
      }
    }
  ],
  "title": "test schema"
}

Parameters

Name In Type Required Description
body body mycujoo.metadata.v1beta1.CreateSchemaRequest true none

Example responses

200 Response

{
  "id": "ck9be30x30lnk1cmsengq2tq2"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.CreateSchemaResponse
default Default An unexpected error response. google.rpc.Status

Gets schema from the system by specified id

Code samples

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

r = requests.get('/metadata/v1beta1/schemas/{id}', headers = headers)

print(r.json())

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

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

GET /metadata/v1beta1/schemas/{id} HTTP/1.1

Accept: application/json


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

fetch('/metadata/v1beta1/schemas/{id}',
{
  method: 'GET',

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

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

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

fetch('/metadata/v1beta1/schemas/{id}',
{
  method: 'GET',

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

GET /metadata/v1beta1/schemas/{id}

Returns schema that matches specified id

Parameters

Name In Type Required Description
id path string true ID of the schema

Example responses

200 Response

{
  "schema": {
    "fields": [
      {
        "name": "title",
        "type": "string"
      },
      {
        "name": "competitionName",
        "type": [
          "null",
          "string"
        ]
      },
      {
        "name": "team",
        "type": {
          "fields": [
            {
              "name": "name",
              "type": "string"
            },
            {
              "name": "players",
              "type": {
                "default": [],
                "items": "string",
                "type": "array"
              }
            }
          ],
          "name": "recordTeam",
          "type": "record"
        }
      }
    ],
    "id": "1do8zuDeZKfh2YSgzd2ek69jhOY",
    "title": "test schema"
  }
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.GetSchemaResponse
default Default An unexpected error response. google.rpc.Status

Removes schema from the system

Code samples

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

r = requests.delete('/metadata/v1beta1/schemas/{id}', headers = headers)

print(r.json())

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

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

DELETE /metadata/v1beta1/schemas/{id} HTTP/1.1

Accept: application/json


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

fetch('/metadata/v1beta1/schemas/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/metadata/v1beta1/schemas/{id}',
{
  method: 'DELETE',

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

DELETE /metadata/v1beta1/schemas/{id}

Removes schema that matches specified id

Parameters

Name In Type Required Description
id path string true ID of the schema to delete

Example responses

200 Response

{
  "id": "ck9be30x30lnk1cmsengq2tq2"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.metadata.v1beta1.DeleteSchemaResponse
default Default An unexpected error response. google.rpc.Status

Updates schema in the system by specified id

Code samples

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

r = requests.patch('/metadata/v1beta1/schemas/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PATCH", "/metadata/v1beta1/schemas/{id}", data)
    req.Header = headers

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

PATCH /metadata/v1beta1/schemas/{id} HTTP/1.1

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

const inputBody = '{
  "fields": [
    {
      "name": "title",
      "type": "string"
    }
  ],
  "title": "Final 2021"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/metadata/v1beta1/schemas/{id}',
{
  method: 'PATCH',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "fields": [
    {
      "name": "title",
      "type": "string"
    }
  ],
  "title": "Final 2021"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'
};

fetch('/metadata/v1beta1/schemas/{id}',
{
  method: 'PATCH',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

PATCH /metadata/v1beta1/schemas/{id}

Updates schema that matches specified id

Body parameter

{
  "fields": [
    {
      "name": "title",
      "type": "string"
    }
  ],
  "title": "Final 2021"
}

Parameters

Name In Type Required Description
id path string true ID of the schema
update_mask query array[string] false The mask to control which fields get updated.
body body mycujoo.metadata.v1beta1.UpdateSchemaRequest.UpdateFields true none

Example responses

200 Response

{
  "category": "string",
  "fields": [
    {}
  ],
  "id": "string",
  "title": "string"
}

Responses

Status Meaning Description Schema
200 OK Updated schema mycujoo.metadata.v1beta1.Schema
default Default An unexpected error response. google.rpc.Status

StreamService

Returns asset information

Code samples

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

r = requests.get('/streaming/v1beta2/assets/recording/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/streaming/v1beta2/assets/recording/{id}", data)
    req.Header = headers

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

GET /streaming/v1beta2/assets/recording/{id} HTTP/1.1

Accept: application/json


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

fetch('/streaming/v1beta2/assets/recording/{id}',
{
  method: 'GET',

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

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

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

fetch('/streaming/v1beta2/assets/recording/{id}',
{
  method: 'GET',

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

GET /streaming/v1beta2/assets/recording/{id}

Get recording's asset information

Parameters

Name In Type Required Description
id path string true The asset's id

Example responses

200 Response

{
  "asset_url": "string",
  "id": "string",
  "is_concatenated": true,
  "status": "STATUS_UNSPECIFIED",
  "stream_id": "string",
  "stream_key": "string"
}

Responses

Status Meaning Description Schema
200 OK (empty) mycujoo.streaming.v1beta2.RecordingAsset
default Default An unexpected error response. google.rpc.Status

Deletes a single recording asset

Code samples

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

r = requests.delete('/streaming/v1beta2/assets/recording/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/streaming/v1beta2/assets/recording/{id}", data)
    req.Header = headers

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

DELETE /streaming/v1beta2/assets/recording/{id} HTTP/1.1

Accept: application/json


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

fetch('/streaming/v1beta2/assets/recording/{id}',
{
  method: 'DELETE',

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

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

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

fetch('/streaming/v1beta2/assets/recording/{id}',
{
  method: 'DELETE',

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

DELETE /streaming/v1beta2/assets/recording/{id}

Deletes a single recording asset

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.streaming.v1beta2.DeleteRecordingAssetResponse
default Default An unexpected error response. google.rpc.Status

Returns a list of clips

Code samples

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

r = requests.get('/streaming/v1beta2/clips', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/streaming/v1beta2/clips", data)
    req.Header = headers

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

GET /streaming/v1beta2/clips HTTP/1.1

Accept: application/json


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

fetch('/streaming/v1beta2/clips',
{
  method: 'GET',

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

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

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

fetch('/streaming/v1beta2/clips',
{
  method: 'GET',

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

GET /streaming/v1beta2/clips

List all clips

Parameters

Name In Type Required Description
filter query string false Filter options, can be filtered by the stream_id, or duration for example.
page_size query integer(int32) false A positive number that is the maximum number of results to return.
page_token query string false If this field is not empty then it must contain the next_page_token value

Detailed descriptions

page_token: If this field is not empty then it must contain the next_page_token value returned by a previous call to this method. Using this field causes the method to return additional results from the previous method call.

Example responses

200 Response

{
  "clips": [
    {
      "actual_duration": 0,
      "actual_position": 0,
      "created_time": "2019-08-24T14:15:22Z",
      "full_url": "string",
      "id": "string",
      "stream_id": "string",
      "title": "string",
      "updated_time": "2019-08-24T14:15:22Z"
    }
  ],
  "next_page_token": "string"
}

Responses

Status Meaning Description Schema
200 OK A successful response. mycujoo.streaming.v1beta2.ListClipsResponse
default Default An unexpected error response. google.rpc.Status

Creates a new Clip

Code samples

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

r = requests.post('/streaming/v1beta2/clips', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "/streaming/v1beta2/clips", data)
    req.Header = headers

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

POST /streaming/v1beta2/clips HTTP/1.1

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

const inputBody = '{
  "duration": 0,
  "position": 0,
  "stream_id": "string",
  "title": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/streaming/v1beta2/clips',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

const fetch = require('node-fetch');
const inputBody = {
  "duration": 0,
  "position": 0,
  "stream_id": "string",
  "title": "string"
};
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'API_KEY'
};

fetch('/streaming/v1beta2/clips',
{
  method: 'POST',
  body: JSON.stringify(inputBody),
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

POST /streaming/v1beta2/clips

Creates a new clip

Body parameter

{
  "duration": 0,
  "position": 0,
  "stream_id": "string",
  "title": "string"
}

Parameters

Name In Type Required Description
body body mycujoo.streaming.v1beta2.ClipRequest true none

Example responses

200 Response

{
  "actual_duration": 0,
  "actual_position": 0,
  "created_time": "2019-08-24T14:15:22Z",
  "full_url": "string",
  "id": "string",
  "stream_id": "string",
  "title": "string",
  "updated_time": "2019-08-24T14:15:22Z"
}

Responses

Status Meaning Description Schema
200 OK (empty) mycujoo.streaming.v1beta2.ClipResponse
default Default An unexpected error response. google.rpc.Status

Returns a single clip

Code samples

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

r = requests.get('/streaming/v1beta2/clips/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "/streaming/v1beta2/clips/{id}", data)
    req.Header = headers

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

GET /streaming/v1beta2/clips/{id} HTTP/1.1

Accept: application/json


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

fetch('/streaming/v1beta2/clips/{id}',
{
  method: 'GET',

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

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

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

fetch('/streaming/v1beta2/clips/{id}',
{
  method: 'GET',

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

GET /streaming/v1beta2/clips/{id}

Fetches a single clip

Parameters

Name In Type Required Description
id path string true none

Example responses

200 Response

{
  "actual_duration": 0,
  "actual_position": 0,
  "created_time": "2019-08-24T14:15:22Z",
  "full_url": "string",
  "id": "string",
  "stream_id": "string",
  "title": "string",
  "updated_time": "2019-08-24T14:15:22Z"
}

Responses

Status Meaning Description Schema
200 OK (empty) mycujoo.streaming.v1beta2.ClipResponse
default Default An unexpected error response. google.rpc.Status

Deletes a single clip

Code samples

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

r = requests.delete('/streaming/v1beta2/clips/{id}', headers = headers)

print(r.json())

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "/streaming/v1beta2/clips/{id}", data)
    req.Header = headers

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

DELETE /streaming/v1beta2/clips/{id} HTTP/1.1

Accept: application/json


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

fetch('/streaming/v1beta2/clips/{id}',
{
  method: 'DELETE',

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