Get Started

ReverseProxy

All
Api Keys
Authorization
Catalogs
Claims
Config
Machines
Orchestrator
Packer Templates
ReverseProxy
Roles
Users

ReverseProxy endpoints

This document contains the endpoints for the ReverseProxy category.

Gets reverse proxy configuration:

/api/v1/reverse-proxy Authorized

This endpoint returns the reverse proxy configuration

Request examples
/v1/reverse-proxy Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/reverse-proxy");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "enabled": "bool",
  "host": "string",
  "port": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the reverse proxy hosts:

/api/v1/reverse-proxy/hosts Authorized

This endpoint returns all the reverse proxy hosts

Request examples
/v1/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets all the reverse proxy host:

/api/v1/reverse-proxy/hosts/{id} Authorized

This endpoint returns a reverse proxy host

Parameters
id Reverse Proxy Host ID required path
Request examples
/v1/reverse-proxy/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id} ' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/reverse-proxy/hosts/{id} ");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id} "
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a reverse proxy host:

/api/v1/reverse-proxy/hosts Authorized

This endpoint creates a reverse proxy host

Parameters
reverse_proxy_create_request Reverse Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates a reverse proxy host:

/api/v1/reverse-proxy/hosts/{id} Authorized

This endpoint creates a reverse proxy host

Parameters
reverse_proxy_update_request Reverse Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/reverse-proxy/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}"
  method := "put"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Delete a a reverse proxy host:

/api/v1/reverse-proxy/hosts/{id} Authorized

This endpoint Deletes a reverse proxy host

Parameters
id Reverse Proxy Host ID required path
Request examples
/v1/reverse-proxy/hosts/{id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/reverse-proxy/hosts/{id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates or updates a reverse proxy host HTTP route:

/api/v1/reverse-proxy/hosts/{id}/http_route Authorized

This endpoint creates or updates a reverse proxy host HTTP route

Parameters
reverse_proxy_http_route_request Reverse Host Request body 
{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}
Request examples
/v1/reverse-proxy/hosts/{id}/http_route Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route"
  method := "post"
  payload := strings.NewReader(`{
  "path": "string",
  "pattern": "string",
  "request_headers": "map[string]string",
  "response_headers": "map[string]string",
  "schema": "string",
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Delete a a reverse proxy host HTTP route:

/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id} Authorized

This endpoint Deletes a reverse proxy host HTTP route

Parameters
id Reverse Proxy Host ID required path http_route_id Reverse Proxy Host HTTP Route ID required path
Request examples
/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id} Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/{http_route_id}"
  method := "delete"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates a reverse proxy host TCP route:

/api/v1/reverse-proxy/hosts/{id}/http_routes Authorized

This endpoint updates a reverse proxy host TCP route

Parameters
reverse_proxy_tcp_route_request Reverse Host Request body 
{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}
Request examples
/v1/reverse-proxy/hosts/{id}/http_routes Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes"
  method := "post"
  payload := strings.NewReader(`{
  "target_host": "string",
  "target_port": "string",
  "target_vm_id": "string"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts the reverse proxy:

/api/v1/reverse-proxy/restart Authorized

This endpoint will restart the reverse proxy

Request examples
/v1/reverse-proxy/restart Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/restart' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/restart"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Enable the reverse proxy:

/api/v1/reverse-proxy/enable Authorized

This endpoint will enable the reverse proxy

Request examples
/v1/reverse-proxy/enable Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/enable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/enable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/enable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Disable the reverse proxy:

/api/v1/reverse-proxy/disable Authorized

This endpoint will disable the reverse proxy

Request examples
/v1/reverse-proxy/disable Authorized 
curl --location 'http://localhost/api/v1/reverse-proxy/disable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/disable");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/reverse-proxy/disable"
  method := "put"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}