# Get all addons and providers

GET https://app.unleash-instance.example.com/api/admin/addons

Retrieve all addons and providers that are defined on this Unleash instance.

Reference: https://docs.getunleash.io/api/get-addons

## OpenAPI Specification

```yaml
openapi: 3.1.1
info:
  title: Get all addons and providers
  version: endpoint_addons.getAddons
paths:
  /api/admin/addons:
    get:
      operationId: get-addons
      summary: Get all addons and providers
      description: >-
        Retrieve all addons and providers that are defined on this Unleash
        instance.
      tags:
        - - subpackage_addons
      parameters:
        - name: Authorization
          in: header
          description: Header authentication of the form `undefined <token>`
          required: true
          schema:
            type: string
      responses:
        '200':
          description: addonsSchema
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/addonsSchema'
        '401':
          description: >-
            Authorization information is missing or invalid. Provide a valid API
            token as the `authorization` header, e.g.
            `authorization:*.*.my-admin-token`.
          content: {}
components:
  schemas:
    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
    tagTypeSchema:
      type: object
      properties:
        name:
          type: string
          description: The name of the tag type.
        description:
          type: string
          description: The description of the tag type.
        icon:
          type:
            - string
            - 'null'
          description: The icon of the tag type.
        color:
          type:
            - string
            - 'null'
          description: The hexadecimal color code for the tag type.
      required:
        - name
    addonParameterSchema:
      type: object
      properties:
        name:
          type: string
          description: >-
            The name of the parameter as it is used in code. References to this
            parameter should use this value.
        displayName:
          type: string
          description: >-
            The name of the parameter as it is shown to the end user in the
            Admin UI.
        type:
          type: string
          description: >-
            The type of the parameter. Corresponds roughly to [HTML `input`
            field
            types](https://developer.mozilla.org/docs/Web/HTML/Element/Input#input_types).
            Multi-line inut fields are indicated as `textfield` (equivalent to
            the HTML `textarea` tag).
        description:
          type: string
          description: >-
            A description of the parameter. This should explain to the end user
            what the parameter is used for.
        placeholder:
          type: string
          description: >-
            The default value for this parameter. This value is used if no other
            value is provided.
        required:
          type: boolean
          description: >-
            Whether this parameter is required or not. If a parameter is
            required, you must give it a value when you create the addon. If it
            is not required it can be left out. It may receive a default value
            in those cases.
        sensitive:
          type: boolean
          description: >-
            Indicates whether this parameter is **sensitive** or not. Unleash
            will not return sensitive parameters to API requests. It will
            instead use a number of asterisks to indicate that a value is set,
            e.g. "******". The number of asterisks does not correlate to the
            parameter's value.
      required:
        - name
        - displayName
        - type
        - required
        - sensitive
    AddonTypeSchemaInstallation:
      type: object
      properties:
        url:
          type: string
          description: >-
            A URL to where the addon configuration should redirect to install
            addons of this type.
        title:
          type: string
          description: >-
            The title of the installation configuration. This will be displayed
            to the user when installing addons of this type.
        helpText:
          type: string
          description: >-
            The help text of the installation configuration. This will be
            displayed to the user when installing addons of this type.
      required:
        - url
    AddonTypeSchemaAlertsItemsType:
      type: string
      enum:
        - value: success
        - value: info
        - value: warning
        - value: error
    AddonTypeSchemaAlertsItems:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/AddonTypeSchemaAlertsItemsType'
          description: The type of alert. This determines the color of the alert.
        text:
          type: string
          description: The text of the alert. This is what will be displayed to the user.
      required:
        - type
        - text
    addonTypeSchema:
      type: object
      properties:
        name:
          type: string
          description: >-
            The name of the addon type. When creating new addons, this goes in
            the payload's `type` field.
        displayName:
          type: string
          description: The addon type's name as it should be displayed in the admin UI.
        documentationUrl:
          type: string
          description: >-
            A URL to where you can find more information about using this addon
            type.
        description:
          type: string
          description: A description of the addon type.
        howTo:
          type: string
          description: >-
            A long description of how to use this addon type. This will be
            displayed on the top of configuration page. Can contain markdown.
        tagTypes:
          type: array
          items:
            $ref: '#/components/schemas/tagTypeSchema'
          description: >-
            A list of [Unleash tag
            types](https://docs.getunleash.io/concepts/feature-flags#tags) that
            this addon uses. These tags will be added to the Unleash instance
            when an addon of this type is created.
        parameters:
          type: array
          items:
            $ref: '#/components/schemas/addonParameterSchema'
          description: >-
            The addon provider's parameters. Use these to configure an addon of
            this provider type. Items with `required: true` must be provided.
        events:
          type: array
          items:
            type: string
          description: >-
            All the [event
            types](https://docs.getunleash.io/concepts/events#event-types) that
            are available for this addon provider.
        installation:
          $ref: '#/components/schemas/AddonTypeSchemaInstallation'
          description: The installation configuration for this addon type.
        alerts:
          type: array
          items:
            $ref: '#/components/schemas/AddonTypeSchemaAlertsItems'
          description: >-
            A list of alerts to display to the user when installing addons of
            this type.
        deprecated:
          type: string
          description: >-
            This should be used to inform the user that this addon type is
            deprecated and should not be used. Deprecated addons will show a
            badge with this information on the UI.
      required:
        - name
        - displayName
        - documentationUrl
        - description
    addonsSchema:
      type: object
      properties:
        addons:
          type: array
          items:
            $ref: '#/components/schemas/addonSchema'
          description: All the addons that exist on this instance of Unleash.
        providers:
          type: array
          items:
            $ref: '#/components/schemas/addonTypeSchema'
          description: >-
            A list of  all available addon providers, along with their
            parameters and descriptions.
      required:
        - addons
        - providers

```

## SDK Code Examples

```python
import requests

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

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://app.unleash-instance.example.com/api/admin/addons';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

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"
	"net/http"
	"io"
)

func main() {

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

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<apiKey>")

	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")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<apiKey>'

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.get("https://app.unleash-instance.example.com/api/admin/addons")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://app.unleash-instance.example.com/api/admin/addons', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.unleash-instance.example.com/api/admin/addons");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "<apiKey>"]

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

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()
```