API reference

Browse all endpoints grouped by tag. For auth, tenancy, and error handling see the integration guide.

OpenAPI definition vv0

article-controller

GET/api/v1/articles

ReturnsResponseListArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "body": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/articles'

fetch("http://localhost/api/v1/articles", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/articles

ReturnsResponseArticleView

AcceptsCreateArticleRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "title": "string"
}' 'http://localhost/api/v1/articles'

fetch("http://localhost/api/v1/articles", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "title": "string" }

GET/api/v1/articles/{articleId}

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/articles/{articleId}'

fetch("http://localhost/api/v1/articles/{articleId}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/articles/{articleId}

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

AcceptsUpdateArticleRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "title": "string",
  "body": "string",
  "excerpt": "string"
}' 'http://localhost/api/v1/articles/{articleId}'

fetch("http://localhost/api/v1/articles/{articleId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"title\": \"string\",\n  \"body\": \"string\",\n  \"excerpt\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"title\": \"string\",\n  \"body\": \"string\",\n  \"excerpt\": \"string\"\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "title": "string", "body": "string", "excerpt": "string" }

POST/api/v1/articles/{articleId}/archive

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/articles/{articleId}/archive'

fetch("http://localhost/api/v1/articles/{articleId}/archive", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/archive"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/articles/{articleId}/cancel-schedule

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/articles/{articleId}/cancel-schedule'

fetch("http://localhost/api/v1/articles/{articleId}/cancel-schedule", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/cancel-schedule"

response = requests.post(url)
print(response.json())

Paste cURL

PUT/api/v1/articles/{articleId}/categories

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

AcceptsReplaceCategoriesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "categoryIds": [
    0
  ]
}' 'http://localhost/api/v1/articles/{articleId}/categories'

fetch("http://localhost/api/v1/articles/{articleId}/categories", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"categoryIds\": [\n    0\n  ]\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/categories"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"categoryIds\": [\n    0\n  ]\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "categoryIds": [ 0 ] }

POST/api/v1/articles/{articleId}/publish

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

AcceptsPublishOptionsRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "notifySubscribers": true,
  "publishedAt": "2024-01-15T09:30:00Z"
}' 'http://localhost/api/v1/articles/{articleId}/publish'

fetch("http://localhost/api/v1/articles/{articleId}/publish", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"notifySubscribers\": true,\n  \"publishedAt\": \"2024-01-15T09:30:00Z\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/publish"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"notifySubscribers\": true,\n  \"publishedAt\": \"2024-01-15T09:30:00Z\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "notifySubscribers": true, "publishedAt": "2024-01-15T09:30:00Z" }

POST/api/v1/articles/{articleId}/schedule

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

AcceptsScheduleArticleRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "scheduledAt": "2024-01-15T09:30:00Z"
}' 'http://localhost/api/v1/articles/{articleId}/schedule'

fetch("http://localhost/api/v1/articles/{articleId}/schedule", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"scheduledAt\": \"2024-01-15T09:30:00Z\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/schedule"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"scheduledAt\": \"2024-01-15T09:30:00Z\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "scheduledAt": "2024-01-15T09:30:00Z" }

POST/api/v1/articles/{articleId}/unarchive

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/articles/{articleId}/unarchive'

fetch("http://localhost/api/v1/articles/{articleId}/unarchive", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/unarchive"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/articles/{articleId}/unpublish

Parameters 1

Name	Type	Description
articleIdrequired	path · integer

ReturnsResponseArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/articles/{articleId}/unpublish'

fetch("http://localhost/api/v1/articles/{articleId}/unpublish", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/articles/{articleId}/unpublish"

response = requests.post(url)
print(response.json())

Paste cURL

auth-controller

POST/api/v1/auth/accept-invite

ReturnsResponseAcceptInviteResponse

AcceptsAcceptInviteRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "token": "string"
}' 'http://localhost/api/v1/auth/accept-invite'

fetch("http://localhost/api/v1/auth/accept-invite", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"token\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/auth/accept-invite"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"token\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "token": "string" }

POST/api/v1/auth/forgot-password

ReturnsResponseForgotPasswordResponse

AcceptsForgotPasswordRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "devResetToken": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string"
}' 'http://localhost/api/v1/auth/forgot-password'

fetch("http://localhost/api/v1/auth/forgot-password", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/auth/forgot-password"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "email": "string" }

POST/api/v1/auth/register

ReturnsResponseRegisterResponse

AcceptsRegisterRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string",
  "password": "string"
}' 'http://localhost/api/v1/auth/register'

fetch("http://localhost/api/v1/auth/register", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\",\n  \"password\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/auth/register"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\",\n  \"password\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

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

POST/api/v1/auth/reset-password

ReturnsResponseVoid

AcceptsResetPasswordRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "newPassword": "string",
  "token": "string"
}' 'http://localhost/api/v1/auth/reset-password'

fetch("http://localhost/api/v1/auth/reset-password", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"newPassword\": \"string\",\n  \"token\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/auth/reset-password"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"newPassword\": \"string\",\n  \"token\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "newPassword": "string", "token": "string" }

POST/api/v1/auth/verify-email

ReturnsResponseVerifyEmailResponse

AcceptsVerifyEmailRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "token": "string"
}' 'http://localhost/api/v1/auth/verify-email'

fetch("http://localhost/api/v1/auth/verify-email", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"token\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/auth/verify-email"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"token\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "token": "string" }

episode-controller

GET/api/v1/episodes

ReturnsResponseListEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "seriesId": 0,
      "seriesSlug": "string",
      "episodeNumber": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/episodes'

fetch("http://localhost/api/v1/episodes", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/episodes

ReturnsResponseEpisodeView

AcceptsCreateEpisodeRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "seriesId": 0,
  "slug": "string",
  "title": "string"
}' 'http://localhost/api/v1/episodes'

fetch("http://localhost/api/v1/episodes", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"seriesId\": 0,\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"seriesId\": 0,\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "seriesId": 0, "slug": "string", "title": "string" }

GET/api/v1/episodes/{episodeId}

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/episodes/{episodeId}'

fetch("http://localhost/api/v1/episodes/{episodeId}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/episodes/{episodeId}

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsUpdateEpisodeRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "episodeNumber": 0,
  "slug": "string",
  "title": "string",
  "description": "string"
}' 'http://localhost/api/v1/episodes/{episodeId}'

fetch("http://localhost/api/v1/episodes/{episodeId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"episodeNumber\": 0,\n  \"slug\": \"string\",\n  \"title\": \"string\",\n  \"description\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"episodeNumber\": 0,\n  \"slug\": \"string\",\n  \"title\": \"string\",\n  \"description\": \"string\"\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "episodeNumber": 0, "slug": "string", "title": "string", "description": "string" }

POST/api/v1/episodes/{episodeId}/archive

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/episodes/{episodeId}/archive'

fetch("http://localhost/api/v1/episodes/{episodeId}/archive", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/archive"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/episodes/{episodeId}/audio

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsAttachAudioRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "audioAssetId": 0
}' 'http://localhost/api/v1/episodes/{episodeId}/audio'

fetch("http://localhost/api/v1/episodes/{episodeId}/audio", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"audioAssetId\": 0\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/audio"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"audioAssetId\": 0\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "audioAssetId": 0 }

POST/api/v1/episodes/{episodeId}/cancel-schedule

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/episodes/{episodeId}/cancel-schedule'

fetch("http://localhost/api/v1/episodes/{episodeId}/cancel-schedule", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/cancel-schedule"

response = requests.post(url)
print(response.json())

Paste cURL

PUT/api/v1/episodes/{episodeId}/categories

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsReplaceCategoriesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "categoryIds": [
    0
  ]
}' 'http://localhost/api/v1/episodes/{episodeId}/categories'

fetch("http://localhost/api/v1/episodes/{episodeId}/categories", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"categoryIds\": [\n    0\n  ]\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/categories"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"categoryIds\": [\n    0\n  ]\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "categoryIds": [ 0 ] }

PUT/api/v1/episodes/{episodeId}/enclosure-enabled

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsEnclosureEnabledRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "enabled": true
}' 'http://localhost/api/v1/episodes/{episodeId}/enclosure-enabled'

fetch("http://localhost/api/v1/episodes/{episodeId}/enclosure-enabled", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"enabled\": true\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/enclosure-enabled"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"enabled\": true\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "enabled": true }

PUT/api/v1/episodes/{episodeId}/formats

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsReplaceFormatsRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "formatIds": [
    0
  ]
}' 'http://localhost/api/v1/episodes/{episodeId}/formats'

fetch("http://localhost/api/v1/episodes/{episodeId}/formats", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"formatIds\": [\n    0\n  ]\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/formats"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"formatIds\": [\n    0\n  ]\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "formatIds": [ 0 ] }

POST/api/v1/episodes/{episodeId}/publish

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsPublishOptionsRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "notifySubscribers": true,
  "publishedAt": "2024-01-15T09:30:00Z"
}' 'http://localhost/api/v1/episodes/{episodeId}/publish'

fetch("http://localhost/api/v1/episodes/{episodeId}/publish", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"notifySubscribers\": true,\n  \"publishedAt\": \"2024-01-15T09:30:00Z\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/publish"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"notifySubscribers\": true,\n  \"publishedAt\": \"2024-01-15T09:30:00Z\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "notifySubscribers": true, "publishedAt": "2024-01-15T09:30:00Z" }

POST/api/v1/episodes/{episodeId}/schedule

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

AcceptsScheduleEpisodeRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "scheduledAt": "2024-01-15T09:30:00Z"
}' 'http://localhost/api/v1/episodes/{episodeId}/schedule'

fetch("http://localhost/api/v1/episodes/{episodeId}/schedule", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"scheduledAt\": \"2024-01-15T09:30:00Z\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/schedule"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"scheduledAt\": \"2024-01-15T09:30:00Z\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "scheduledAt": "2024-01-15T09:30:00Z" }

POST/api/v1/episodes/{episodeId}/unarchive

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/episodes/{episodeId}/unarchive'

fetch("http://localhost/api/v1/episodes/{episodeId}/unarchive", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/unarchive"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/episodes/{episodeId}/unpublish

Parameters 1

Name	Type	Description
episodeIdrequired	path · integer

ReturnsResponseEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "seriesId": 0,
    "seriesSlug": "string",
    "episodeNumber": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/episodes/{episodeId}/unpublish'

fetch("http://localhost/api/v1/episodes/{episodeId}/unpublish", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/episodes/{episodeId}/unpublish"

response = requests.post(url)
print(response.json())

Paste cURL

me-article-controller

GET/api/v1/me/articles

ReturnsResponseListMeArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "body": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/articles'

fetch("http://localhost/api/v1/me/articles", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/articles"

response = requests.get(url)
print(response.json())

Paste cURL

me-billing-controller

POST/api/v1/me/billing/checkout-sessions

ReturnsResponseCheckoutSessionView

AcceptsCheckoutSessionRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "url": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "productSlug": "string"
}' 'http://localhost/api/v1/me/billing/checkout-sessions'

fetch("http://localhost/api/v1/me/billing/checkout-sessions", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"productSlug\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/billing/checkout-sessions"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"productSlug\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "productSlug": "string" }

POST/api/v1/me/billing/portal

ReturnsResponseCheckoutSessionView

AcceptsPortalRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "url": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "returnUrl": "string"
}' 'http://localhost/api/v1/me/billing/portal'

fetch("http://localhost/api/v1/me/billing/portal", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"returnUrl\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/billing/portal"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"returnUrl\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "returnUrl": "string" }

me-controller

GET/api/v1/me

ReturnsResponseMeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "email": "string",
    "name": "string",
    "roles": [
      "string"
    ],
    "tenantId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me'

fetch("http://localhost/api/v1/me", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/me/access

ReturnsResponseAccessResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "activeLevels": [
      {
        "id": 0,
        "slug": "string",
        "title": "string",
        "sortOrder": 0
      }
    ],
    "maxLevelSortOrder": 0,
    "activePackages": [
      {
        "id": 0,
        "slug": "string",
        "title": "string"
      }
    ],
    "roles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/access'

fetch("http://localhost/api/v1/me/access", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/access"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/me/subscriptions

ReturnsResponseListSubscriptionView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "userId": 0,
      "email": "string",
      "productId": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/subscriptions'

fetch("http://localhost/api/v1/me/subscriptions", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/subscriptions"

response = requests.get(url)
print(response.json())

Paste cURL

me-downloads-controller

GET/api/v1/me/downloads

ReturnsResponseListDownloadView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "title": "string",
      "assetType": "string",
      "mimeType": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/downloads'

fetch("http://localhost/api/v1/me/downloads", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/downloads"

response = requests.get(url)
print(response.json())

Paste cURL

me-episode-controller

GET/api/v1/me/episodes

ReturnsResponseListMeEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "seriesId": 0,
      "seriesSlug": "string",
      "episodeNumber": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/episodes'

fetch("http://localhost/api/v1/me/episodes", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/episodes"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/me/episodes/{slug}/stream

Parameters 1

Name	Type	Description
slugrequired	path · string

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/episodes/{slug}/stream'

fetch("http://localhost/api/v1/me/episodes/{slug}/stream", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/episodes/{slug}/stream"

response = requests.get(url)
print(response.json())

Paste cURL

me-feed-controller

GET/api/v1/me/feeds

ReturnsResponseListSubscriberFeedView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "title": "string",
      "isDefault": true,
      "enabled": true
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/feeds'

fetch("http://localhost/api/v1/me/feeds", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/me/feeds

ReturnsResponseSubscriberFeedView

AcceptsCreateCustomFeedRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "title": "string",
  "formatIds": [
    0
  ]
}' 'http://localhost/api/v1/me/feeds'

fetch("http://localhost/api/v1/me/feeds", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"title\": \"string\",\n  \"formatIds\": [\n    0\n  ]\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"title\": \"string\",\n  \"formatIds\": [\n    0\n  ]\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "title": "string", "formatIds": [ 0 ] }

PUT/api/v1/me/feeds/{feedId}

Parameters 1

Name	Type	Description
feedIdrequired	path · integer

ReturnsResponseSubscriberFeedView

AcceptsUpdateCustomFeedRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "title": "string",
  "formatIds": [
    0
  ]
}' 'http://localhost/api/v1/me/feeds/{feedId}'

fetch("http://localhost/api/v1/me/feeds/{feedId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"title\": \"string\",\n  \"formatIds\": [\n    0\n  ]\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/{feedId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"title\": \"string\",\n  \"formatIds\": [\n    0\n  ]\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "title": "string", "formatIds": [ 0 ] }

DELETE/api/v1/me/feeds/{feedId}

Parameters 1

Name	Type	Description
feedIdrequired	path · integer

ReturnsResponseSubscriberFeedView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/me/feeds/{feedId}'

fetch("http://localhost/api/v1/me/feeds/{feedId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/{feedId}"

response = requests.delete(url)
print(response.json())

Paste cURL

PUT/api/v1/me/feeds/{feedId}/enabled

Parameters 1

Name	Type	Description
feedIdrequired	path · integer

ReturnsResponseSubscriberFeedView

AcceptsFeedEnabledRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "enabled": true
}' 'http://localhost/api/v1/me/feeds/{feedId}/enabled'

fetch("http://localhost/api/v1/me/feeds/{feedId}/enabled", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"enabled\": true\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/{feedId}/enabled"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"enabled\": true\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "enabled": true }

GET/api/v1/me/feeds/{feedId}/preview

Parameters 1

Name	Type	Description
feedIdrequired	path · integer

ReturnsResponseFeedPreviewView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "episodeCount": 0,
    "sampleTitles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/feeds/{feedId}/preview'

fetch("http://localhost/api/v1/me/feeds/{feedId}/preview", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/{feedId}/preview"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/me/feeds/{feedId}/rotate-token

Parameters 1

Name	Type	Description
feedIdrequired	path · integer

ReturnsResponseSubscriberFeedView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/me/feeds/{feedId}/rotate-token'

fetch("http://localhost/api/v1/me/feeds/{feedId}/rotate-token", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/{feedId}/rotate-token"

response = requests.post(url)
print(response.json())

Paste cURL

PUT/api/v1/me/feeds/default/enabled

ReturnsResponseSubscriberFeedView

AcceptsFeedEnabledRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "enabled": true
}' 'http://localhost/api/v1/me/feeds/default/enabled'

fetch("http://localhost/api/v1/me/feeds/default/enabled", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"enabled\": true\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/default/enabled"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"enabled\": true\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "enabled": true }

POST/api/v1/me/feeds/default/rotate-token

ReturnsResponseSubscriberFeedView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "title": "string",
    "isDefault": true,
    "enabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/me/feeds/default/rotate-token'

fetch("http://localhost/api/v1/me/feeds/default/rotate-token", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/default/rotate-token"

response = requests.post(url)
print(response.json())

Paste cURL

GET/api/v1/me/feeds/preview

Parameters 1

Name	Type	Description
formatIdsrequired	query · array

ReturnsResponseFeedPreviewView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "episodeCount": 0,
    "sampleTitles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/feeds/preview'

fetch("http://localhost/api/v1/me/feeds/preview", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/feeds/preview"

response = requests.get(url)
print(response.json())

Paste cURL

me-notification-preferences-controller

GET/api/v1/me/notification-preferences

ReturnsResponseNotificationPreferencesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "emailNotificationsEnabled": true,
    "emailNotifyAvailable": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/me/notification-preferences'

fetch("http://localhost/api/v1/me/notification-preferences", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/notification-preferences"

response = requests.get(url)
print(response.json())

Paste cURL

PATCH/api/v1/me/notification-preferences

ReturnsResponseNotificationPreferencesView

AcceptsUpdateNotificationPreferencesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "emailNotificationsEnabled": true,
    "emailNotifyAvailable": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PATCH -H 'Content-Type: application/json' -d '{
  "emailNotificationsEnabled": true
}' 'http://localhost/api/v1/me/notification-preferences'

fetch("http://localhost/api/v1/me/notification-preferences", {
  method: "PATCH",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"emailNotificationsEnabled\": true\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/me/notification-preferences"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"emailNotificationsEnabled\": true\n}"

response = requests.patch(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "emailNotificationsEnabled": true }

media-controller

GET/api/v1/media

Parameters 3

Name	Type	Description
assetType	query · string
status	query · string
limit	query · integer

ReturnsResponseListMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "s3Key": "string",
      "visibility": "string",
      "scope": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/media'

fetch("http://localhost/api/v1/media", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/media"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/media/{id}

Parameters 1

Name	Type	Description
idrequired	path · integer

ReturnsResponseMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/media/{id}'

fetch("http://localhost/api/v1/media/{id}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/media/{id}"

response = requests.get(url)
print(response.json())

Paste cURL

DELETE/api/v1/media/{id}

Parameters 1

Name	Type	Description
idrequired	path · integer

ReturnsResponseMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/media/{id}'

fetch("http://localhost/api/v1/media/{id}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/media/{id}"

response = requests.delete(url)
print(response.json())

Paste cURL

POST/api/v1/media/{id}/confirm

Parameters 1

Name	Type	Description
idrequired	path · integer

ReturnsResponseMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/media/{id}/confirm'

fetch("http://localhost/api/v1/media/{id}/confirm", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/media/{id}/confirm"

response = requests.post(url)
print(response.json())

Paste cURL

GET/api/v1/media/{id}/preview-url

Parameters 2

Name	Type	Description
idrequired	path · integer
previewDraft	query · boolean

ReturnsResponsePreviewUrlResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "url": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/media/{id}/preview-url'

fetch("http://localhost/api/v1/media/{id}/preview-url", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/media/{id}/preview-url"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/media/upload-url

ReturnsResponseUploadUrlResponse

AcceptsCreateUploadUrlRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "assetId": 0,
    "uploadUrl": "string",
    "expiresAt": "2024-01-15T09:30:00Z",
    "headers": {}
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "assetType": "AUDIO",
  "filename": "string",
  "mimeType": "string"
}' 'http://localhost/api/v1/media/upload-url'

fetch("http://localhost/api/v1/media/upload-url", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"assetType\": \"AUDIO\",\n  \"filename\": \"string\",\n  \"mimeType\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/media/upload-url"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"assetType\": \"AUDIO\",\n  \"filename\": \"string\",\n  \"mimeType\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "assetType": "AUDIO", "filename": "string", "mimeType": "string" }

module-probe-controller

GET/api/v1/probes/digital

ReturnsResponseProbeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "module": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/probes/digital'

fetch("http://localhost/api/v1/probes/digital", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/probes/digital"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/probes/podcast

ReturnsResponseProbeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "module": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/probes/podcast'

fetch("http://localhost/api/v1/probes/podcast", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/probes/podcast"

response = requests.get(url)
print(response.json())

Paste cURL

platform-admin-controller

GET/api/v1/platform/admins

ReturnsResponseListPlatformAdminView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "userId": 0,
      "email": "string",
      "name": "string",
      "lastLoginAt": "2024-01-15T09:30:00Z"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/admins'

fetch("http://localhost/api/v1/platform/admins", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/admins"

response = requests.get(url)
print(response.json())

Paste cURL

DELETE/api/v1/platform/admins/{userId}

Parameters 1

Name	Type	Description
userIdrequired	path · integer

ReturnsResponsePlatformAdminView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "lastLoginAt": "2024-01-15T09:30:00Z"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/platform/admins/{userId}'

fetch("http://localhost/api/v1/platform/admins/{userId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/admins/{userId}"

response = requests.delete(url)
print(response.json())

Paste cURL

POST/api/v1/platform/admins/invite

ReturnsResponsePlatformAdminInvitationResponse

AcceptsInvitePlatformAdminRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string"
}' 'http://localhost/api/v1/platform/admins/invite'

fetch("http://localhost/api/v1/platform/admins/invite", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/admins/invite"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "email": "string" }

platform-audit-controller

GET/api/v1/platform/audit

Parameters 6

Name	Type	Description
page	query · integer
size	query · integer
tenantId	query · integer

ReturnsResponseListPlatformAuditView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "action": "string",
      "actorUserId": 0,
      "actorEmail": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/audit'

fetch("http://localhost/api/v1/platform/audit", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/audit"

response = requests.get(url)
print(response.json())

Paste cURL

platform-module-controller

GET/api/v1/platform/modules

ReturnsResponseListModuleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "moduleKey": "string",
      "name": "string",
      "description": "string",
      "dependsOn": [
        "string"
      ]
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/modules'

fetch("http://localhost/api/v1/platform/modules", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/modules"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/platform/tenants/{tenantId}/modules

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseTenantModulesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "enabledModules": [
      "string"
    ],
    "activations": [
      {
        "moduleKey": "string",
        "active": true,
        "activatedAt": "2024-01-15T09:30:00Z",
        "source": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/tenants/{tenantId}/modules'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/modules", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/modules"

response = requests.get(url)
print(response.json())

Paste cURL

DELETE/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
moduleKeyrequired	path · string

ReturnsResponseTenantModulesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "enabledModules": [
      "string"
    ],
    "activations": [
      {
        "moduleKey": "string",
        "active": true,
        "activatedAt": "2024-01-15T09:30:00Z",
        "source": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}"

response = requests.delete(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}/activate

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
moduleKeyrequired	path · string

ReturnsResponseTenantModulesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "enabledModules": [
      "string"
    ],
    "activations": [
      {
        "moduleKey": "string",
        "active": true,
        "activatedAt": "2024-01-15T09:30:00Z",
        "source": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}/activate'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}/activate", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/modules/{moduleKey}/activate"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/modules/preset/{presetKey}

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
presetKeyrequired	path · string

ReturnsResponseTenantModulesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "enabledModules": [
      "string"
    ],
    "activations": [
      {
        "moduleKey": "string",
        "active": true,
        "activatedAt": "2024-01-15T09:30:00Z",
        "source": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/modules/preset/{presetKey}'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/modules/preset/{presetKey}", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/modules/preset/{presetKey}"

response = requests.post(url)
print(response.json())

Paste cURL

platform-overview-controller

GET/api/v1/platform/overview

Parameters 1

Name	Type	Description
recentAuditLimit	query · integer

ReturnsResponsePlatformOverviewView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "tenantCounts": {
      "active": 0,
      "suspended": 0
    },
    "moduleAdoption": [
      {
        "moduleKey": "string",
        "tenantCount": 0
      }
    ],
    "recentAudit": [
      {
        "id": 0,
        "action": "string",
        "actorUserId": 0,
        "actorEmail": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/overview'

fetch("http://localhost/api/v1/platform/overview", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/overview"

response = requests.get(url)
print(response.json())

Paste cURL

platform-queue-controller

GET/api/v1/platform/queue/jobs

Parameters 7

Name	Type	Description
queue	query · string
status	query · string
tenantId	query · integer

ReturnsResponseListQueueJob

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": "00000000-0000-4000-8000-000000000000",
      "queue": "string",
      "payload": {
        "array": true,
        "empty": true,
        "null": true,
        "float": true
      },
      "priority": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/queue/jobs'

fetch("http://localhost/api/v1/platform/queue/jobs", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/queue/jobs"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/platform/queue/jobs

ReturnsResponseQueueJob

AcceptsEnqueueJobRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": "00000000-0000-4000-8000-000000000000",
    "queue": "string",
    "payload": {
      "array": true,
      "empty": true,
      "null": true,
      "float": true
    },
    "priority": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "payload": {
    "array": true,
    "empty": true,
    "null": true,
    "float": true
  },
  "queue": "string"
}' 'http://localhost/api/v1/platform/queue/jobs'

fetch("http://localhost/api/v1/platform/queue/jobs", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"payload\": {\n    \"array\": true,\n    \"empty\": true,\n    \"null\": true,\n    \"float\": true\n  },\n  \"queue\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/queue/jobs"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"payload\": {\n    \"array\": true,\n    \"empty\": true,\n    \"null\": true,\n    \"float\": true\n  },\n  \"queue\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "payload": { "array": true, "empty": true, "null": true, "float": true }, "queue": "string" }

GET/api/v1/platform/queue/jobs/{id}

Parameters 1

Name	Type	Description
idrequired	path · string

ReturnsResponseQueueJob

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": "00000000-0000-4000-8000-000000000000",
    "queue": "string",
    "payload": {
      "array": true,
      "empty": true,
      "null": true,
      "float": true
    },
    "priority": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/queue/jobs/{id}'

fetch("http://localhost/api/v1/platform/queue/jobs/{id}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/queue/jobs/{id}"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/platform/queue/jobs/{id}/complete

Parameters 1

Name	Type	Description
idrequired	path · string

ReturnsResponseQueueJob

AcceptsCompleteJobRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": "00000000-0000-4000-8000-000000000000",
    "queue": "string",
    "payload": {
      "array": true,
      "empty": true,
      "null": true,
      "float": true
    },
    "priority": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "worker": "string"
}' 'http://localhost/api/v1/platform/queue/jobs/{id}/complete'

fetch("http://localhost/api/v1/platform/queue/jobs/{id}/complete", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"worker\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/queue/jobs/{id}/complete"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"worker\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "worker": "string" }

POST/api/v1/platform/queue/jobs/{id}/fail

Parameters 1

Name	Type	Description
idrequired	path · string

ReturnsResponseQueueJob

AcceptsFailJobRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": "00000000-0000-4000-8000-000000000000",
    "queue": "string",
    "payload": {
      "array": true,
      "empty": true,
      "null": true,
      "float": true
    },
    "priority": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "error": "string",
  "worker": "string"
}' 'http://localhost/api/v1/platform/queue/jobs/{id}/fail'

fetch("http://localhost/api/v1/platform/queue/jobs/{id}/fail", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"error\": \"string\",\n  \"worker\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/queue/jobs/{id}/fail"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"error\": \"string\",\n  \"worker\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "error": "string", "worker": "string" }

POST/api/v1/platform/queue/jobs/claim

ReturnsResponseListQueueJob

AcceptsClaimJobsRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": "00000000-0000-4000-8000-000000000000",
      "queue": "string",
      "payload": {
        "array": true,
        "empty": true,
        "null": true,
        "float": true
      },
      "priority": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "queue": "string",
  "worker": "string"
}' 'http://localhost/api/v1/platform/queue/jobs/claim'

fetch("http://localhost/api/v1/platform/queue/jobs/claim", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"queue\": \"string\",\n  \"worker\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/queue/jobs/claim"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"queue\": \"string\",\n  \"worker\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "queue": "string", "worker": "string" }

platform-tenant-controller

GET/api/v1/platform/tenants

ReturnsResponseTenantListResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "content": [
      {
        "id": 0,
        "slug": "string",
        "name": "string",
        "status": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/tenants'

fetch("http://localhost/api/v1/platform/tenants", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants

ReturnsResponseTenantCreationResponse

AcceptsCreateTenantRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "name": "string",
  "slug": "string"
}' 'http://localhost/api/v1/platform/tenants'

fetch("http://localhost/api/v1/platform/tenants", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "name": "string", "slug": "string" }

GET/api/v1/platform/tenants/{tenantId}

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseTenantDetailResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "tenant": {
      "id": 0,
      "slug": "string",
      "name": "string",
      "status": "string"
    },
    "episodeCount": 0,
    "subscriberCount": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/tenants/{tenantId}'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}"

response = requests.get(url)
print(response.json())

Paste cURL

PATCH/api/v1/platform/tenants/{tenantId}

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseTenantDetailView

AcceptsUpdateTenantRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PATCH -H 'Content-Type: application/json' -d '{
  "name": "string",
  "slug": "string"
}' 'http://localhost/api/v1/platform/tenants/{tenantId}'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}", {
  method: "PATCH",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}"

response = requests.patch(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "name": "string", "slug": "string" }

POST/api/v1/platform/tenants/{tenantId}/domains/{host}/verify

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
hostrequired	path · string

ReturnsResponseDomainView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "host": "string",
    "primary": true,
    "verified": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/domains/{host}/verify'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/domains/{host}/verify", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/domains/{host}/verify"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/reactivate

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseTenantDetailView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/reactivate'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/reactivate", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/reactivate"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/suspend

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseTenantDetailView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "status": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/suspend'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/suspend", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/suspend"

response = requests.post(url)
print(response.json())

Paste cURL

platform-tenant-media-controller

GET/api/v1/platform/tenants/{tenantId}/media

Parameters 4

Name	Type	Description
tenantIdrequired	path · integer
assetType	query · string
status	query · string

ReturnsResponseTenantMediaListResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "content": [
      {
        "id": 0,
        "s3Key": "string",
        "visibility": "string",
        "scope": "string"
      }
    ],
    "publicCdnBaseUrl": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/tenants/{tenantId}/media'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/media", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/media"

response = requests.get(url)
print(response.json())

Paste cURL

DELETE/api/v1/platform/tenants/{tenantId}/media/{assetId}

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
assetIdrequired	path · integer

ReturnsResponseMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/platform/tenants/{tenantId}/media/{assetId}'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/media/{assetId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/media/{assetId}"

response = requests.delete(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/media/{assetId}/confirm

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
assetIdrequired	path · integer

ReturnsResponseMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/media/{assetId}/confirm'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/media/{assetId}/confirm", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/media/{assetId}/confirm"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/media/upload-url

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseUploadUrlResponse

AcceptsCreateUploadUrlRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "assetId": 0,
    "uploadUrl": "string",
    "expiresAt": "2024-01-15T09:30:00Z",
    "headers": {}
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "assetType": "AUDIO",
  "filename": "string",
  "mimeType": "string"
}' 'http://localhost/api/v1/platform/tenants/{tenantId}/media/upload-url'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/media/upload-url", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"assetType\": \"AUDIO\",\n  \"filename\": \"string\",\n  \"mimeType\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/media/upload-url"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"assetType\": \"AUDIO\",\n  \"filename\": \"string\",\n  \"mimeType\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "assetType": "AUDIO", "filename": "string", "mimeType": "string" }

platform-tenant-user-controller

GET/api/v1/platform/tenants/{tenantId}/users

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseTenantUserListResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "content": [
      {
        "userId": 0,
        "email": "string",
        "name": "string",
        "roles": [
          "string"
        ]
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/platform/tenants/{tenantId}/users'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/users", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/users"

response = requests.get(url)
print(response.json())

Paste cURL

PATCH/api/v1/platform/tenants/{tenantId}/users/{userId}

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
userIdrequired	path · integer

ReturnsResponseTenantUserView

AcceptsUpdateTenantUserRoleRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "roles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PATCH -H 'Content-Type: application/json' -d '{
  "role": "string"
}' 'http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}", {
  method: "PATCH",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"role\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"role\": \"string\"\n}"

response = requests.patch(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "role": "string" }

POST/api/v1/platform/tenants/{tenantId}/users/{userId}/deactivate

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
userIdrequired	path · integer

ReturnsResponseTenantUserView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "roles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/deactivate'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/deactivate", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/deactivate"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/users/{userId}/reactivate

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
userIdrequired	path · integer

ReturnsResponseTenantUserView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "roles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/reactivate'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/reactivate", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/reactivate"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/users/{userId}/resend-invite

Parameters 2

Name	Type	Description
tenantIdrequired	path · integer
userIdrequired	path · integer

ReturnsResponseInviteUserResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "email": "string",
    "role": "string",
    "status": "string",
    "inviteToken": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/resend-invite'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/resend-invite", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/users/{userId}/resend-invite"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/platform/tenants/{tenantId}/users/invite

Parameters 1

Name	Type	Description
tenantIdrequired	path · integer

ReturnsResponseInviteUserResponse

AcceptsInviteTenantUserRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "email": "string",
    "role": "string",
    "status": "string",
    "inviteToken": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string",
  "role": "string"
}' 'http://localhost/api/v1/platform/tenants/{tenantId}/users/invite'

fetch("http://localhost/api/v1/platform/tenants/{tenantId}/users/invite", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\",\n  \"role\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/platform/tenants/{tenantId}/users/invite"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\",\n  \"role\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "email": "string", "role": "string" }

podcast-import-controller

POST/api/v1/podcast/import/assets

ReturnsResponseMediaAssetView

AcceptsIngestAssetRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "assetType": "AUDIO",
  "sourceUrl": "string"
}' 'http://localhost/api/v1/podcast/import/assets'

fetch("http://localhost/api/v1/podcast/import/assets", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"assetType\": \"AUDIO\",\n  \"sourceUrl\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/podcast/import/assets"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"assetType\": \"AUDIO\",\n  \"sourceUrl\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "assetType": "AUDIO", "sourceUrl": "string" }

GET/api/v1/podcast/import/assets/{assetId}

Parameters 1

Name	Type	Description
assetIdrequired	path · integer

ReturnsResponseMediaAssetView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "s3Key": "string",
    "visibility": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/podcast/import/assets/{assetId}'

fetch("http://localhost/api/v1/podcast/import/assets/{assetId}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/podcast/import/assets/{assetId}"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/podcast/import/episodes

ReturnsResponseImportedEpisodeView

AcceptsImportEpisodeRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "episode": {
      "id": 0,
      "seriesId": 0,
      "seriesSlug": "string",
      "episodeNumber": 0
    },
    "alreadyImported": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "feedUrl": "string",
  "guid": "string",
  "seriesId": 0,
  "title": "string"
}' 'http://localhost/api/v1/podcast/import/episodes'

fetch("http://localhost/api/v1/podcast/import/episodes", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"feedUrl\": \"string\",\n  \"guid\": \"string\",\n  \"seriesId\": 0,\n  \"title\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/podcast/import/episodes"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"feedUrl\": \"string\",\n  \"guid\": \"string\",\n  \"seriesId\": 0,\n  \"title\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "feedUrl": "string", "guid": "string", "seriesId": 0, "title": "string" }

POST/api/v1/podcast/import/preview

ReturnsResponsePreviewView

AcceptsPreviewRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "feedUrl": "string",
    "channel": {
      "title": "string",
      "description": "string",
      "language": "string",
      "itunesCategory": "string"
    },
    "episodes": [
      {
        "guid": "string",
        "title": "string",
        "description": "string",
        "publishedAt": "string"
      }
    ],
    "truncated": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "feedUrl": "string"
}' 'http://localhost/api/v1/podcast/import/preview'

fetch("http://localhost/api/v1/podcast/import/preview", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"feedUrl\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/podcast/import/preview"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"feedUrl\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "feedUrl": "string" }

public-altcha-controller

GET/api/v1/public/altcha/challenge

Response examples

200OK

application/json example derived from schema

"string"

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/altcha/challenge'

fetch("http://localhost/api/v1/public/altcha/challenge", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/altcha/challenge"

response = requests.get(url)
print(response.json())

Paste cURL

public-article-controller

GET/api/v1/public/articles

ReturnsResponseListPublicArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "body": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/articles'

fetch("http://localhost/api/v1/public/articles", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/articles"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/public/articles/{slug}

Parameters 1

Name	Type	Description
slugrequired	path · string

ReturnsResponsePublicArticleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "body": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/articles/{slug}'

fetch("http://localhost/api/v1/public/articles/{slug}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/articles/{slug}"

response = requests.get(url)
print(response.json())

Paste cURL

public-contact-controller

POST/api/v1/public/contact

ReturnsResponseContactAcceptedResponse

AcceptsContactRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "accepted": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "altcha": "string",
  "email": "string",
  "message": "string",
  "name": "string"
}' 'http://localhost/api/v1/public/contact'

fetch("http://localhost/api/v1/public/contact", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"altcha\": \"string\",\n  \"email\": \"string\",\n  \"message\": \"string\",\n  \"name\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/contact"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"altcha\": \"string\",\n  \"email\": \"string\",\n  \"message\": \"string\",\n  \"name\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "altcha": "string", "email": "string", "message": "string", "name": "string" }

public-episode-download-controller

GET/api/v1/public/episodes/{slug}/download

Parameters 1

Name	Type	Description
slugrequired	path · string

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/episodes/{slug}/download'

fetch("http://localhost/api/v1/public/episodes/{slug}/download", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/episodes/{slug}/download"

response = requests.get(url)
print(response.json())

Paste cURL

public-level-controller

GET/api/v1/public/levels

ReturnsResponseListLevelView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "sortOrder": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/levels'

fetch("http://localhost/api/v1/public/levels", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/levels"

response = requests.get(url)
print(response.json())

Paste cURL

public-podcast-controller

GET/api/v1/public/categories

ReturnsResponseListPublicCategoryView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "name": "string",
      "parentId": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/categories'

fetch("http://localhost/api/v1/public/categories", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/categories"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/public/episodes

Parameters 1

Name	Type	Description
seriesId	query · integer

ReturnsResponseListPublicEpisodeView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "seriesId": 0,
      "seriesSlug": "string",
      "episodeNumber": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/episodes'

fetch("http://localhost/api/v1/public/episodes", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/episodes"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/public/formats

ReturnsResponseListPublicFormatView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "name": "string",
      "description": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/formats'

fetch("http://localhost/api/v1/public/formats", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/formats"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/public/series

ReturnsResponseListPublicSeriesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "description": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/series'

fetch("http://localhost/api/v1/public/series", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/series"

response = requests.get(url)
print(response.json())

Paste cURL

public-site-config-controller

GET/api/v1/public/site-config

ReturnsResponseSiteConfigResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "tenant": {
      "slug": "string",
      "name": "string"
    },
    "enabledModules": [
      "string"
    ],
    "branding": {
      "siteTitle": "string",
      "primaryColor": "string",
      "secondaryColor": "string",
      "logoUrl": "string"
    },
    "publicSiteUrl": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/site-config'

fetch("http://localhost/api/v1/public/site-config", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/site-config"

response = requests.get(url)
print(response.json())

Paste cURL

public-subscription-product-controller

GET/api/v1/public/products

ReturnsResponseListProductView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "offeringType": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/public/products'

fetch("http://localhost/api/v1/public/products", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/public/products"

response = requests.get(url)
print(response.json())

Paste cURL

rss-feed-controller

GET/feeds/{tenantSlug}/{seriesSlug}.xml

Parameters 2

Name	Type	Description
tenantSlugrequired	path · string
seriesSlugrequired	path · string

Response examples

200OK

*/* example derived from schema

"string"

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/feeds/{tenantSlug}/{seriesSlug}.xml'

fetch("http://localhost/feeds/{tenantSlug}/{seriesSlug}.xml", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/feeds/{tenantSlug}/{seriesSlug}.xml"

response = requests.get(url)
print(response.json())

Paste cURL

GET/feeds/{tenantSlug}/e/{episodeSlug}.mp3

Parameters 2

Name	Type	Description
tenantSlugrequired	path · string
episodeSlugrequired	path · string

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/feeds/{tenantSlug}/e/{episodeSlug}.mp3'

fetch("http://localhost/feeds/{tenantSlug}/e/{episodeSlug}.mp3", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/feeds/{tenantSlug}/e/{episodeSlug}.mp3"

response = requests.get(url)
print(response.json())

Paste cURL

GET/feeds/{tenantSlug}/podcast.xml

Parameters 1

Name	Type	Description
tenantSlugrequired	path · string

Response examples

200OK

*/* example derived from schema

"string"

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/feeds/{tenantSlug}/podcast.xml'

fetch("http://localhost/feeds/{tenantSlug}/podcast.xml", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/feeds/{tenantSlug}/podcast.xml"

response = requests.get(url)
print(response.json())

Paste cURL

GET/feeds/{tenantSlug}/u/{feedToken}.xml

Parameters 2

Name	Type	Description
tenantSlugrequired	path · string
feedTokenrequired	path · string

Response examples

200OK

*/* example derived from schema

"string"

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/feeds/{tenantSlug}/u/{feedToken}.xml'

fetch("http://localhost/feeds/{tenantSlug}/u/{feedToken}.xml", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/feeds/{tenantSlug}/u/{feedToken}.xml"

response = requests.get(url)
print(response.json())

Paste cURL

GET/feeds/{tenantSlug}/u/{feedToken}/e/{episodeSlug}.mp3

Parameters 3

Name	Type	Description
tenantSlugrequired	path · string
feedTokenrequired	path · string
episodeSlugrequired	path · string

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/feeds/{tenantSlug}/u/{feedToken}/e/{episodeSlug}.mp3'

fetch("http://localhost/feeds/{tenantSlug}/u/{feedToken}/e/{episodeSlug}.mp3", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/feeds/{tenantSlug}/u/{feedToken}/e/{episodeSlug}.mp3"

response = requests.get(url)
print(response.json())

Paste cURL

security-probe-controller

GET/api/v1/security/context

ReturnsResponseSecurityContextView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "roles": [
      "string"
    ],
    "tenantId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/security/context'

fetch("http://localhost/api/v1/security/context", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/security/context"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/security/editor

ReturnsResponseRoleProbeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "role": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/security/editor'

fetch("http://localhost/api/v1/security/editor", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/security/editor"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/security/platform

ReturnsResponseRoleProbeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "role": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/security/platform'

fetch("http://localhost/api/v1/security/platform", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/security/platform"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/security/subscriber

ReturnsResponseRoleProbeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "role": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/security/subscriber'

fetch("http://localhost/api/v1/security/subscriber", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/security/subscriber"

response = requests.get(url)
print(response.json())

Paste cURL

GET/api/v1/security/tenant-admin

ReturnsResponseRoleProbeResponse

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "role": "string",
    "scope": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/security/tenant-admin'

fetch("http://localhost/api/v1/security/tenant-admin", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/security/tenant-admin"

response = requests.get(url)
print(response.json())

Paste cURL

series-controller

GET/api/v1/series

ReturnsResponseListSeriesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "description": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/series'

fetch("http://localhost/api/v1/series", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/series"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/series

ReturnsResponseSeriesView

AcceptsCreateSeriesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "description": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "title": "string"
}' 'http://localhost/api/v1/series'

fetch("http://localhost/api/v1/series", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/series"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "title": "string" }

GET/api/v1/series/{seriesId}

Parameters 1

Name	Type	Description
seriesIdrequired	path · integer

ReturnsResponseSeriesView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "description": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/series/{seriesId}'

fetch("http://localhost/api/v1/series/{seriesId}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/series/{seriesId}"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/series/{seriesId}

Parameters 1

Name	Type	Description
seriesIdrequired	path · integer

ReturnsResponseSeriesView

AcceptsUpdateSeriesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "description": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "title": "string",
  "description": "string",
  "coverAssetId": 0
}' 'http://localhost/api/v1/series/{seriesId}'

fetch("http://localhost/api/v1/series/{seriesId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"title\": \"string\",\n  \"description\": \"string\",\n  \"coverAssetId\": 0\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/series/{seriesId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"title\": \"string\",\n  \"description\": \"string\",\n  \"coverAssetId\": 0\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "title": "string", "description": "string", "coverAssetId": 0 }

stripe-webhook-controller

POST/api/v1/webhooks/stripe

Parameters 1

Name	Type	Description
Stripe-Signature	header · string

ReturnsResponseVoid

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '"string"' 'http://localhost/api/v1/webhooks/stripe'

fetch("http://localhost/api/v1/webhooks/stripe", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "\"string\"",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/webhooks/stripe"
headers = {
    "Content-Type": "application/json"
}
data = "\"string\""

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

"string"

studio-auth-controller

POST/api/v1/auth/studio/workspaces

ReturnsResponseStudioWorkspacesResponse

AcceptsStudioWorkspacesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "workspaces": [
      {
        "tenantId": 0,
        "slug": "string",
        "name": "string",
        "host": "string"
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string",
  "password": "string"
}' 'http://localhost/api/v1/auth/studio/workspaces'

fetch("http://localhost/api/v1/auth/studio/workspaces", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\",\n  \"password\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/auth/studio/workspaces"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\",\n  \"password\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

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

tenant-admin-controller

GET/api/v1/tenant/branding

ReturnsResponseBrandingView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "siteTitle": "string",
    "primaryColor": "string",
    "secondaryColor": "string",
    "logoUrl": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/branding'

fetch("http://localhost/api/v1/tenant/branding", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/branding"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/tenant/branding

ReturnsResponseBrandingView

AcceptsBrandingUpdateRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "siteTitle": "string",
    "primaryColor": "string",
    "secondaryColor": "string",
    "logoUrl": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "siteTitle": "string",
  "primaryColor": "string",
  "secondaryColor": "string",
  "logoUrl": "string"
}' 'http://localhost/api/v1/tenant/branding'

fetch("http://localhost/api/v1/tenant/branding", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"siteTitle\": \"string\",\n  \"primaryColor\": \"string\",\n  \"secondaryColor\": \"string\",\n  \"logoUrl\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/branding"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"siteTitle\": \"string\",\n  \"primaryColor\": \"string\",\n  \"secondaryColor\": \"string\",\n  \"logoUrl\": \"string\"\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "siteTitle": "string", "primaryColor": "string", "secondaryColor": "string", "logoUrl": "string" }

GET/api/v1/tenant/domains

ReturnsResponseListDomainView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "host": "string",
      "primary": true,
      "verified": true
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/domains'

fetch("http://localhost/api/v1/tenant/domains", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/domains"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/tenant/domains

ReturnsResponseDomainView

AcceptsAddDomainRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "host": "string",
    "primary": true,
    "verified": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "host": "string"
}' 'http://localhost/api/v1/tenant/domains'

fetch("http://localhost/api/v1/tenant/domains", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"host\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/domains"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"host\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "host": "string" }

GET/api/v1/tenant/domains/{host}/verification

Parameters 1

Name	Type	Description
hostrequired	path · string

ReturnsResponseDomainVerificationView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "host": "string",
    "token": "string",
    "dnsTxtValue": "string",
    "dnsNameHint": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/domains/{host}/verification'

fetch("http://localhost/api/v1/tenant/domains/{host}/verification", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/domains/{host}/verification"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/tenant/domains/{host}/verify

Parameters 1

Name	Type	Description
hostrequired	path · string

ReturnsResponseDomainView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "host": "string",
    "primary": true,
    "verified": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/tenant/domains/{host}/verify'

fetch("http://localhost/api/v1/tenant/domains/{host}/verify", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/domains/{host}/verify"

response = requests.post(url)
print(response.json())

Paste cURL

GET/api/v1/tenant/users

ReturnsResponseListUserView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "userId": 0,
      "email": "string",
      "name": "string",
      "roles": [
        "string"
      ]
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/users'

fetch("http://localhost/api/v1/tenant/users", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/users"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/tenant/users/{userId}/deactivate

Parameters 1

Name	Type	Description
userIdrequired	path · integer

ReturnsResponseTenantUserView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "roles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/tenant/users/{userId}/deactivate'

fetch("http://localhost/api/v1/tenant/users/{userId}/deactivate", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/users/{userId}/deactivate"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/tenant/users/{userId}/reactivate

Parameters 1

Name	Type	Description
userIdrequired	path · integer

ReturnsResponseTenantUserView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "userId": 0,
    "email": "string",
    "name": "string",
    "roles": [
      "string"
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/tenant/users/{userId}/reactivate'

fetch("http://localhost/api/v1/tenant/users/{userId}/reactivate", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/users/{userId}/reactivate"

response = requests.post(url)
print(response.json())

Paste cURL

POST/api/v1/tenant/users/invite

ReturnsResponseInviteUserResponse

AcceptsInviteRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "email": "string",
    "role": "string",
    "status": "string",
    "inviteToken": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string",
  "role": "string"
}' 'http://localhost/api/v1/tenant/users/invite'

fetch("http://localhost/api/v1/tenant/users/invite", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\",\n  \"role\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/users/invite"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\",\n  \"role\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "email": "string", "role": "string" }

tenant-billing-dashboard-controller

GET/api/v1/tenant/billing/dashboard

ReturnsResponseBillingDashboard

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "stripe": {
      "status": "string",
      "moduleEnabled": true,
      "message": "string",
      "chargesEnabled": true
    },
    "stats": {
      "activeSubscriptions": 0,
      "activePaidSubscriptions": 0,
      "activeGrantSubscriptions": 0,
      "uniqueActiveMembers": 0
    },
    "memberships": [
      {
        "id": 0,
        "userId": 0,
        "email": "string",
        "productId": 0
      }
    ]
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/billing/dashboard'

fetch("http://localhost/api/v1/tenant/billing/dashboard", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/billing/dashboard"

response = requests.get(url)
print(response.json())

Paste cURL

tenant-category-controller

GET/api/v1/categories

ReturnsResponseListCategoryView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "name": "string",
      "parentId": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/categories'

fetch("http://localhost/api/v1/categories", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/categories"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/categories

ReturnsResponseCategoryView

AcceptsCreateCategoryRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "parentId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "name": "string",
  "slug": "string"
}' 'http://localhost/api/v1/categories'

fetch("http://localhost/api/v1/categories", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/categories"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "name": "string", "slug": "string" }

PUT/api/v1/categories/{categoryId}

Parameters 1

Name	Type	Description
categoryIdrequired	path · integer

ReturnsResponseCategoryView

AcceptsUpdateCategoryRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "parentId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "name": "string",
  "parentId": 0,
  "active": true
}' 'http://localhost/api/v1/categories/{categoryId}'

fetch("http://localhost/api/v1/categories/{categoryId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"name\": \"string\",\n  \"parentId\": 0,\n  \"active\": true\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/categories/{categoryId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"name\": \"string\",\n  \"parentId\": 0,\n  \"active\": true\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "name": "string", "parentId": 0, "active": true }

DELETE/api/v1/categories/{categoryId}

Parameters 1

Name	Type	Description
categoryIdrequired	path · integer

ReturnsResponseCategoryView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "parentId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/categories/{categoryId}'

fetch("http://localhost/api/v1/categories/{categoryId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/categories/{categoryId}"

response = requests.delete(url)
print(response.json())

Paste cURL

tenant-content-email-template-controller

GET/api/v1/tenant/content-email-templates/{contentType}

Parameters 1

Name	Type	Description
contentTyperequired	path · string

ReturnsResponseTemplateView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "contentType": "string",
    "subjectTemplate": "string",
    "bodyHtml": "string",
    "updatedAt": "2024-01-15T09:30:00Z"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/content-email-templates/{contentType}'

fetch("http://localhost/api/v1/tenant/content-email-templates/{contentType}", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/content-email-templates/{contentType}"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/tenant/content-email-templates/{contentType}

Parameters 1

Name	Type	Description
contentTyperequired	path · string

ReturnsResponseTemplateView

AcceptsUpsertContentEmailTemplateRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "contentType": "string",
    "subjectTemplate": "string",
    "bodyHtml": "string",
    "updatedAt": "2024-01-15T09:30:00Z"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "bodyHtml": "string",
  "subjectTemplate": "string"
}' 'http://localhost/api/v1/tenant/content-email-templates/{contentType}'

fetch("http://localhost/api/v1/tenant/content-email-templates/{contentType}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"bodyHtml\": \"string\",\n  \"subjectTemplate\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/content-email-templates/{contentType}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"bodyHtml\": \"string\",\n  \"subjectTemplate\": \"string\"\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "bodyHtml": "string", "subjectTemplate": "string" }

tenant-format-controller

GET/api/v1/formats

ReturnsResponseListFormatView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "name": "string",
      "requiredLevelSortOrder": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/formats'

fetch("http://localhost/api/v1/formats", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/formats"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/formats

ReturnsResponseFormatView

AcceptsCreateFormatRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "requiredLevelSortOrder": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "name": "string",
  "slug": "string"
}' 'http://localhost/api/v1/formats'

fetch("http://localhost/api/v1/formats", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/formats"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"name\": \"string\",\n  \"slug\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "name": "string", "slug": "string" }

PUT/api/v1/formats/{formatId}

Parameters 1

Name	Type	Description
formatIdrequired	path · integer

ReturnsResponseFormatView

AcceptsUpdateFormatRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "requiredLevelSortOrder": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "name": "string",
  "description": "string",
  "requiredLevelSortOrder": 0
}' 'http://localhost/api/v1/formats/{formatId}'

fetch("http://localhost/api/v1/formats/{formatId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"name\": \"string\",\n  \"description\": \"string\",\n  \"requiredLevelSortOrder\": 0\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/formats/{formatId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"name\": \"string\",\n  \"description\": \"string\",\n  \"requiredLevelSortOrder\": 0\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "name": "string", "description": "string", "requiredLevelSortOrder": 0 }

DELETE/api/v1/formats/{formatId}

Parameters 1

Name	Type	Description
formatIdrequired	path · integer

ReturnsResponseFormatView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "name": "string",
    "requiredLevelSortOrder": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/formats/{formatId}'

fetch("http://localhost/api/v1/formats/{formatId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/formats/{formatId}"

response = requests.delete(url)
print(response.json())

Paste cURL

tenant-stripe-controller

POST/api/v1/tenant/stripe/onboard

ReturnsResponseOnboardView

AcceptsOnboardRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "url": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "returnUrl": "string",
  "refreshUrl": "string"
}' 'http://localhost/api/v1/tenant/stripe/onboard'

fetch("http://localhost/api/v1/tenant/stripe/onboard", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"returnUrl\": \"string\",\n  \"refreshUrl\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/stripe/onboard"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"returnUrl\": \"string\",\n  \"refreshUrl\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "returnUrl": "string", "refreshUrl": "string" }

GET/api/v1/tenant/stripe/status

ReturnsResponseStripeStatusView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "status": "string",
    "moduleEnabled": true,
    "message": "string",
    "chargesEnabled": true
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/stripe/status'

fetch("http://localhost/api/v1/tenant/stripe/status", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/stripe/status"

response = requests.get(url)
print(response.json())

Paste cURL

tenant-subscriber-controller

GET/api/v1/tenant/subscribers

ReturnsResponseListSubscriberView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "userId": 0,
      "email": "string",
      "name": "string",
      "status": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/subscribers'

fetch("http://localhost/api/v1/tenant/subscribers", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/subscribers"

response = requests.get(url)
print(response.json())

Paste cURL

tenant-subscriber-feed-controller

GET/api/v1/tenant/subscriber-feeds

ReturnsResponseListSubscriberFeedAdminView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "userId": 0,
      "userEmail": "string",
      "title": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/subscriber-feeds'

fetch("http://localhost/api/v1/tenant/subscriber-feeds", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/subscriber-feeds"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/tenant/subscriber-feeds/{feedId}/enabled

Parameters 1

Name	Type	Description
feedIdrequired	path · integer

ReturnsResponseSubscriberFeedAdminView

AcceptsFeedEnabledRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "userId": 0,
    "userEmail": "string",
    "title": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "enabled": true
}' 'http://localhost/api/v1/tenant/subscriber-feeds/{feedId}/enabled'

fetch("http://localhost/api/v1/tenant/subscriber-feeds/{feedId}/enabled", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"enabled\": true\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/subscriber-feeds/{feedId}/enabled"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"enabled\": true\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "enabled": true }

tenant-subscription-controller

POST/api/v1/tenant/subscriptions

ReturnsResponseSubscriptionView

AcceptsGrantSubscriptionRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "userId": 0,
    "email": "string",
    "productId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "email": "string",
  "productId": 0
}' 'http://localhost/api/v1/tenant/subscriptions'

fetch("http://localhost/api/v1/tenant/subscriptions", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"email\": \"string\",\n  \"productId\": 0\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/subscriptions"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"email\": \"string\",\n  \"productId\": 0\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "email": "string", "productId": 0 }

DELETE/api/v1/tenant/subscriptions/{subscriptionId}

Parameters 1

Name	Type	Description
subscriptionIdrequired	path · integer

ReturnsResponseSubscriptionView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "userId": 0,
    "email": "string",
    "productId": 0
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/tenant/subscriptions/{subscriptionId}'

fetch("http://localhost/api/v1/tenant/subscriptions/{subscriptionId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/subscriptions/{subscriptionId}"

response = requests.delete(url)
print(response.json())

Paste cURL

tenant-subscription-product-controller

GET/api/v1/tenant/products

ReturnsResponseListProductView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "slug": "string",
      "title": "string",
      "offeringType": "string"
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/products'

fetch("http://localhost/api/v1/tenant/products", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products"

response = requests.get(url)
print(response.json())

Paste cURL

POST/api/v1/tenant/products

ReturnsResponseProductView

AcceptsCreateProductRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "offeringType": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST -H 'Content-Type: application/json' -d '{
  "slug": "string",
  "title": "string"
}' 'http://localhost/api/v1/tenant/products'

fetch("http://localhost/api/v1/tenant/products", {
  method: "POST",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"slug\": \"string\",\n  \"title\": \"string\"\n}"

response = requests.post(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "slug": "string", "title": "string" }

PUT/api/v1/tenant/products/{productId}

Parameters 1

Name	Type	Description
productIdrequired	path · integer

ReturnsResponseProductView

AcceptsUpdateProductRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "offeringType": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "title": "string",
  "sortOrder": 0,
  "active": true,
  "description": "string"
}' 'http://localhost/api/v1/tenant/products/{productId}'

fetch("http://localhost/api/v1/tenant/products/{productId}", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"title\": \"string\",\n  \"sortOrder\": 0,\n  \"active\": true,\n  \"description\": \"string\"\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products/{productId}"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"title\": \"string\",\n  \"sortOrder\": 0,\n  \"active\": true,\n  \"description\": \"string\"\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "title": "string", "sortOrder": 0, "active": true, "description": "string" }

DELETE/api/v1/tenant/products/{productId}

Parameters 1

Name	Type	Description
productIdrequired	path · integer

ReturnsResponseProductView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "offeringType": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X DELETE 'http://localhost/api/v1/tenant/products/{productId}'

fetch("http://localhost/api/v1/tenant/products/{productId}", {
  method: "DELETE",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products/{productId}"

response = requests.delete(url)
print(response.json())

Paste cURL

GET/api/v1/tenant/products/{productId}/rules

Parameters 1

Name	Type	Description
productIdrequired	path · integer

ReturnsResponseListProductAccessRuleView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "productId": 0,
      "scopeType": "string",
      "scopeId": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl 'http://localhost/api/v1/tenant/products/{productId}/rules'

fetch("http://localhost/api/v1/tenant/products/{productId}/rules", {
  method: "GET",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products/{productId}/rules"

response = requests.get(url)
print(response.json())

Paste cURL

PUT/api/v1/tenant/products/{productId}/rules

Parameters 1

Name	Type	Description
productIdrequired	path · integer

ReturnsResponseListProductAccessRuleView

AcceptsReplaceRulesRequest

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": [
    {
      "id": 0,
      "productId": 0,
      "scopeType": "string",
      "scopeId": 0
    }
  ],
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X PUT -H 'Content-Type: application/json' -d '{
  "rules": [
    {
      "scopeType": "ALL_PODCASTS"
    }
  ]
}' 'http://localhost/api/v1/tenant/products/{productId}/rules'

fetch("http://localhost/api/v1/tenant/products/{productId}/rules", {
  method: "PUT",
  headers: {
      "Content-Type": "application/json"
    },
  body: "{\n  \"rules\": [\n    {\n      \"scopeType\": \"ALL_PODCASTS\"\n    }\n  ]\n}",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products/{productId}/rules"
headers = {
    "Content-Type": "application/json"
}
data = "{\n  \"rules\": [\n    {\n      \"scopeType\": \"ALL_PODCASTS\"\n    }\n  ]\n}"

response = requests.put(url, headers=headers, data=data)
print(response.json())

Paste cURL

Body:

{ "rules": [ { "scopeType": "ALL_PODCASTS" } ] }

POST/api/v1/tenant/products/{productId}/sync-stripe

Parameters 1

Name	Type	Description
productIdrequired	path · integer

ReturnsResponseProductView

Response examples

200OK

*/* example derived from schema

{
  "statusCode": 0,
  "statusMessage": "string",
  "data": {
    "id": 0,
    "slug": "string",
    "title": "string",
    "offeringType": "string"
  },
  "errors": [
    {
      "code": "string",
      "message": "string",
      "field": "string"
    }
  ]
}

Try ItOpenAPI definition vv0

Code examples

curl -X POST 'http://localhost/api/v1/tenant/products/{productId}/sync-stripe'

fetch("http://localhost/api/v1/tenant/products/{productId}/sync-stripe", {
  method: "POST",
})
  .then((response) => response.json())
  .then((data) => console.log(data))

import requests

url = "http://localhost/api/v1/tenant/products/{productId}/sync-stripe"

response = requests.post(url)
print(response.json())

Paste cURL