# [BETA] Create a signal endpoint.

POST https://app.unleash-instance.example.com/api/admin/signal-endpoints
Content-Type: application/json

**Enterprise feature**

**[BETA]** This API is in beta state, which means it may change or be removed in the future.

Creates a new signal endpoint.

Reference: https://docs.getunleash.io/api/create-signal-endpoint

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: admin-api
  version: 1.0.0
paths:
  /api/admin/signal-endpoints:
    post:
      operationId: create-signal-endpoint
      summary: '[BETA] Create a signal endpoint.'
      description: >-
        **Enterprise feature**


        **[BETA]** This API is in beta state, which means it may change or be
        removed in the future.


        Creates a new signal endpoint.
      tags:
        - subpackage_operational
      parameters:
        - name: Authorization
          in: header
          description: API key needed to access this API
          required: true
          schema:
            type: string
      responses:
        '201':
          description: The resource was successfully created.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/signalEndpointSchema'
        '400':
          description: The request data does not match what we expect.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/CreateSignalEndpointRequestBadRequestError
        '401':
          description: >-
            Authorization information is missing or invalid. Provide a valid API
            token as the `authorization` header, e.g.
            `authorization:*.*.my-admin-token`.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/CreateSignalEndpointRequestUnauthorizedError
        '403':
          description: >-
            The provided user credentials are valid, but the user does not have
            the necessary permissions to perform this operation
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateSignalEndpointRequestForbiddenError'
        '415':
          description: >-
            The operation does not support request payloads of the provided
            type. Please ensure that you're using one of the listed payload
            types and that you have specified the right content type in the
            "content-type" header.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/CreateSignalEndpointRequestUnsupportedMediaTypeError
      requestBody:
        description: '#/components/schemas/createSignalEndpointSchema'
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/createSignalEndpointSchema'
servers:
  - url: https://app.unleash-instance.example.com
components:
  schemas:
    createSignalEndpointSchema:
      type: object
      properties:
        enabled:
          type: boolean
          description: >-
            Whether the signal endpoint is currently enabled. If not specified,
            defaults to true.
        name:
          type: string
          description: The signal endpoint name. Must be URL-safe.
        description:
          type:
            - string
            - 'null'
          description: >-
            A more detailed description of the signal endpoint and its intended
            use.
      required:
        - name
      description: Describes the properties required to create or update a signal endpoint.
      title: createSignalEndpointSchema
    signalEndpointTokenSchema:
      type: object
      properties:
        id:
          type: integer
          description: >-
            The signal endpoint token's ID. Signal endpoint token IDs are
            incrementing integers. In other words, a more recently created
            signal endpoint token will always have a higher ID than an older
            one.
        token:
          type: string
          description: >-
            The token used for authentication. It is automatically generated by
            Unleash when the token is created and that is the only time this
            property is returned.
        name:
          type: string
          description: The signal endpoint token name.
        signalEndpointId:
          type: integer
          description: The signal endpoint ID that this token belongs to.
        createdAt:
          type: string
          format: date-time
          description: The date and time of when the signal endpoint token was created.
        createdByUserId:
          type: integer
          description: The ID of the user that created this signal endpoint token.
      required:
        - id
        - name
        - signalEndpointId
        - createdAt
        - createdByUserId
      description: An object describing a signal endpoint token.
      title: signalEndpointTokenSchema
    signalEndpointSchema:
      type: object
      properties:
        id:
          type: integer
          description: >-
            The signal endpoint's ID. Signal endpoint IDs are incrementing
            integers. In other words, a more recently created signal endpoint
            will always have a higher ID than an older one.
        enabled:
          type: boolean
          description: >-
            Whether the signal endpoint is currently enabled. If not specified,
            defaults to true.
        name:
          type: string
          description: The signal endpoint name. Must be URL-safe.
        description:
          type:
            - string
            - 'null'
          description: >-
            A more detailed description of the signal endpoint and its intended
            use.
        createdAt:
          type: string
          format: date-time
          description: The date and time of when the signal endpoint was created.
        createdByUserId:
          type: integer
          description: The ID of the user that created this signal endpoint.
        url:
          type: string
          description: >-
            The full URL that should be used to call the signal endpoint. This
            property is only returned for newly created or updated signal
            endpoints.
        tokens:
          type: array
          items:
            $ref: '#/components/schemas/signalEndpointTokenSchema'
          description: The list of tokens associated with the signal endpoint.
      required:
        - id
        - enabled
        - name
        - createdAt
        - createdByUserId
      description: An object describing a signal endpoint.
      title: signalEndpointSchema
    CreateSignalEndpointRequestBadRequestError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: CreateSignalEndpointRequestBadRequestError
    CreateSignalEndpointRequestUnauthorizedError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: CreateSignalEndpointRequestUnauthorizedError
    CreateSignalEndpointRequestForbiddenError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: CreateSignalEndpointRequestForbiddenError
    CreateSignalEndpointRequestUnsupportedMediaTypeError:
      type: object
      properties:
        id:
          type: string
          description: The ID of the error instance
        name:
          type: string
          description: The name of the error kind
        message:
          type: string
          description: A description of what went wrong.
      title: CreateSignalEndpointRequestUnsupportedMediaTypeError
  securitySchemes:
    apiKey:
      type: apiKey
      in: header
      name: Authorization
      description: API key needed to access this API
    bearerToken:
      type: http
      scheme: bearer
      description: API key needed to access this API, in Bearer token format

```

## SDK Code Examples

```python
import requests

url = "https://app.unleash-instance.example.com/api/admin/signal-endpoints"

payload = { "name": "cpu-over-90" }
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/admin/signal-endpoints';
const options = {
  method: 'POST',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"name":"cpu-over-90"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://app.unleash-instance.example.com/api/admin/signal-endpoints"

	payload := strings.NewReader("{\n  \"name\": \"cpu-over-90\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://app.unleash-instance.example.com/api/admin/signal-endpoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"cpu-over-90\"\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://app.unleash-instance.example.com/api/admin/signal-endpoints")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"cpu-over-90\"\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://app.unleash-instance.example.com/api/admin/signal-endpoints', [
  'body' => '{
  "name": "cpu-over-90"
}',
  'headers' => [
    'Authorization' => '<apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://app.unleash-instance.example.com/api/admin/signal-endpoints");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"cpu-over-90\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["name": "cpu-over-90"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://app.unleash-instance.example.com/api/admin/signal-endpoints")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```