Gets reverse proxy configuration

/api/v1/reverse-proxy Authorized

This endpoint returns the reverse proxy configuration

Request examples

      
      /v1/reverse-proxy
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

{ object }

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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

{ object }

Gets all the reverse proxy host

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

This endpoint returns a reverse proxy host

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

{ object }

Creates a reverse proxy host

/api/v1/reverse-proxy/hosts Authorized

This endpoint creates a reverse proxy host

Parameters

Name	Type	In	Required	Description
`reverse_proxy_create_request`	`object`	body	optional	Reverse Host Request
Schema `{ object }`

Request examples

      
      /v1/reverse-proxy/hosts
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/reverse-proxy/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Updates a reverse proxy host

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

This endpoint creates a reverse proxy host

Parameters

Name	Type	In	Required	Description
`reverse_proxy_update_request`	`object`	body	optional	Reverse Host Request
Schema `{ object }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Delete a a reverse proxy host

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

This endpoint Deletes a reverse proxy host

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

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

Name	Type	In	Required	Description
`reverse_proxy_http_route_request`	`object`	body	optional	Reverse Host Request
Schema `{ object }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_route' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

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

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID
`http_route_id`	`string`	path	required	Reverse Proxy Host HTTP Route ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

Updates the order of a reverse proxy host HTTP route

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

This endpoint reorders HTTP routes for a reverse proxy host

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Reverse Proxy Host ID
`reverse_proxy_http_route_reorder_request`	`object`	body	optional	Reverse Proxy Host HTTP Route Reorder Request
Schema `{ object }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/order' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes/order");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{ object }");
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/order"
  method := "put"
  payload := strings.NewReader(`{ object }`)
  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

{ object }

{ object }

{ object }

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

Name	Type	In	Required	Description
`reverse_proxy_tcp_route_request`	`object`	body	optional	Reverse Host Request
Schema `{ object }`

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/reverse-proxy/hosts/{id}/http_routes' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

ReverseProxy endpoints

Gets reverse proxy configuration

Gets all the reverse proxy hosts

Gets all the reverse proxy host

Parameters

Creates a reverse proxy host

Parameters

Updates a reverse proxy host

Parameters

Delete a a reverse proxy host

Parameters

Creates or updates a reverse proxy host HTTP route

Parameters

Delete a a reverse proxy host HTTP route

Parameters

Updates the order of a reverse proxy host HTTP route

Parameters

Updates a reverse proxy host TCP route

Parameters

Restarts the reverse proxy

Enable the reverse proxy

Disable the reverse proxy

Cookie Consent