# Update an addon

PUT https://app.unleash-instance.example.com/api/admin/addons/{id}
Content-Type: application/json

Update the addon with a specific ID. Any fields in the update object will be updated. Properties that are not included in the update object will not be affected. To empty a property, pass `null` as that property's value.

Note: passing `null` as a value for the description property will set it to an empty string.

Reference: https://docs.getunleash.io/api/update-addon

## OpenAPI Specification

```yaml
openapi: 3.1.1
info:
  title: Update an addon
  version: endpoint_addons.updateAddon
paths:
  /api/admin/addons/{id}:
    put:
      operationId: update-addon
      summary: Update an addon
      description: >-
        Update the addon with a specific ID. Any fields in the update object
        will be updated. Properties that are not included in the update object
        will not be affected. To empty a property, pass `null` as that
        property's value.


        Note: passing `null` as a value for the description property will set it
        to an empty string.
      tags:
        - - subpackage_addons
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
        - name: Authorization
          in: header
          description: Header authentication of the form `undefined <token>`
          required: true
          schema:
            type: string
      responses:
        '200':
          description: addonSchema
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/addonSchema'
        '400':
          description: The request data does not match what we expect.
          content: {}
        '401':
          description: >-
            Authorization information is missing or invalid. Provide a valid API
            token as the `authorization` header, e.g.
            `authorization:*.*.my-admin-token`.
          content: {}
        '403':
          description: >-
            The provided user credentials are valid, but the user does not have
            the necessary permissions to perform this operation
          content: {}
        '404':
          description: The requested resource was not found.
          content: {}
        '413':
          description: >-
            The request body is larger than what we accept. By default we only
            accept bodies of 100kB or less
          content: {}
        '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: {}
      requestBody:
        description: addonCreateUpdateSchema
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/addonCreateUpdateSchema'
components:
  schemas:
    addonCreateUpdateSchema:
      type: object
      properties:
        provider:
          type: string
          description: >
            The addon provider, such as "webhook" or "slack". This string is
            **case sensitive** and maps to the provider's `name` property.


            The list of all supported providers and their parameters for a
            specific Unleash instance can be found by making a GET request to
            the `api/admin/addons` endpoint: the `providers` property of that
            response will contain all available providers.


            The default set of providers can be found in the [addons reference
            documentation](https://docs.getunleash.io/integrate). The default
            supported options are:

            - `datadog` for
            [Datadog](https://docs.getunleash.io/integrate/datadog)

            - `slack` for [Slack](https://docs.getunleash.io/integrate/slack)

            - `teams` for [Microsoft
            Teams](https://docs.getunleash.io/integrate/teams)

            - `webhook` for
            [webhooks](https://docs.getunleash.io/integrate/webhook)


            The provider you choose for your addon dictates what properties the
            `parameters` object needs. Refer to the documentation for each
            provider for more information.
        description:
          type: string
          description: A description of the addon.
        enabled:
          type: boolean
          description: Whether the addon should be enabled or not.
        parameters:
          type: object
          additionalProperties:
            description: Any type
          description: >-
            Parameters for the addon provider. This object has different
            required and optional properties depending on the provider you
            choose. Consult the documentation for details.
        events:
          type: array
          items:
            type: string
          description: The event types that will trigger this specific addon.
        projects:
          type: array
          items:
            type: string
          description: >-
            The projects that this addon will listen to events from. An empty
            list means it will listen to events from **all** projects.
        environments:
          type: array
          items:
            type: string
          description: >-
            The list of environments that this addon will listen to events from.
            An empty list means it will listen to events from **all**
            environments.
      required:
        - provider
        - enabled
        - parameters
        - events
    addonSchema:
      type: object
      properties:
        id:
          type: integer
          description: The addon's unique identifier.
        provider:
          type: string
          description: The addon provider, such as "webhook" or "slack".
        description:
          type:
            - string
            - 'null'
          description: A description of the addon. `null` if no description exists.
        enabled:
          type: boolean
          description: Whether the addon is enabled or not.
        parameters:
          type: object
          additionalProperties:
            description: Any type
          description: >-
            Parameters for the addon provider. This object has different
            required and optional properties depending on the provider you
            choose.
        events:
          type: array
          items:
            type: string
          description: The event types that trigger this specific addon.
        projects:
          type: array
          items:
            type: string
          description: >-
            The projects that this addon listens to events from. An empty list
            means it listens to events from **all** projects.
        environments:
          type: array
          items:
            type: string
          description: >-
            The list of environments that this addon listens to events from. An
            empty list means it listens to events from **all** environments.
      required:
        - id
        - provider
        - description
        - enabled
        - parameters
        - events

```

## SDK Code Examples

```python
import requests

url = "https://app.unleash-instance.example.com/api/admin/addons/id"

payload = {
    "provider": "webhook",
    "enabled": True,
    "parameters": { "url": "http://localhost:4242/webhook" },
    "events": ["feature-created", "feature-updated"]
}
headers = {
    "Authorization": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/admin/addons/id';
const options = {
  method: 'PUT',
  headers: {Authorization: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"provider":"webhook","enabled":true,"parameters":{"url":"http://localhost:4242/webhook"},"events":["feature-created","feature-updated"]}'
};

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/addons/id"

	payload := strings.NewReader("{\n  \"provider\": \"webhook\",\n  \"enabled\": true,\n  \"parameters\": {\n    \"url\": \"http://localhost:4242/webhook\"\n  },\n  \"events\": [\n    \"feature-created\",\n    \"feature-updated\"\n  ]\n}")

	req, _ := http.NewRequest("PUT", 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/addons/id")

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

request = Net::HTTP::Put.new(url)
request["Authorization"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"provider\": \"webhook\",\n  \"enabled\": true,\n  \"parameters\": {\n    \"url\": \"http://localhost:4242/webhook\"\n  },\n  \"events\": [\n    \"feature-created\",\n    \"feature-updated\"\n  ]\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.put("https://app.unleash-instance.example.com/api/admin/addons/id")
  .header("Authorization", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"provider\": \"webhook\",\n  \"enabled\": true,\n  \"parameters\": {\n    \"url\": \"http://localhost:4242/webhook\"\n  },\n  \"events\": [\n    \"feature-created\",\n    \"feature-updated\"\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://app.unleash-instance.example.com/api/admin/addons/id', [
  'body' => '{
  "provider": "webhook",
  "enabled": true,
  "parameters": {
    "url": "http://localhost:4242/webhook"
  },
  "events": [
    "feature-created",
    "feature-updated"
  ]
}',
  '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/addons/id");
var request = new RestRequest(Method.PUT);
request.AddHeader("Authorization", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"provider\": \"webhook\",\n  \"enabled\": true,\n  \"parameters\": {\n    \"url\": \"http://localhost:4242/webhook\"\n  },\n  \"events\": [\n    \"feature-created\",\n    \"feature-updated\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "provider": "webhook",
  "enabled": true,
  "parameters": ["url": "http://localhost:4242/webhook"],
  "events": ["feature-created", "feature-updated"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://app.unleash-instance.example.com/api/admin/addons/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```