> ## Documentation Index
> Fetch the complete documentation index at: https://docs.reap.video/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Integrations

> List active social media integrations connected to your studio

> **For AI agents:** a documentation index is at [/llms.txt](https://docs.reap.video/llms.txt). Every page is also available as markdown, just append `.md` to the URL.

## Overview

Retrieve all active social media integrations connected to your studio. Use this endpoint to get integration IDs needed for publishing and scheduling clips.

## Rate Limiting

This endpoint allows **60 requests per minute per API key**. Each endpoint has its own budget, so this allowance is not shared with the rest of the API — see [Rate limiting](https://docs.reap.video/api-reference/2_authentication.md#rate-limiting).

> [!NOTE]
>
> Integrations are connected and managed from your Reap dashboard. This endpoint only lists your active integrations.

## Response

**integrations** `array`

Array of active integration objects

**Integration Object**

**id** `string`

Unique integration identifier (use this when publishing or scheduling)

**platform** `string`

Social media platform

* `youtube` - YouTube
* `instagram` - Instagram
* `tiktok` - TikTok
* `linkedin` - LinkedIn
* `x` - X (formerly Twitter)

**isActive** `boolean`

Whether the integration is currently active and ready to publish

**username** `string`

Platform username or handle

**name** `string`

Display name on the platform

**profilePictureUrl** `string`

URL of the profile picture on the platform

## Example Request

```bash cURL theme={"system"}
curl -X GET "https://public.reap.video/api/v1/automation/get-integrations" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"
```

```javascript JavaScript theme={"system"}
const response = await fetch('https://public.reap.video/api/v1/automation/get-integrations', {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
data.integrations.forEach(i => {
  console.log(`${i.platform}: ${i.username} (${i.id})`);
});
```

```python Python theme={"system"}
import requests

headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
}

response = requests.get(
    'https://public.reap.video/api/v1/automation/get-integrations',
    headers=headers
)

data = response.json()
for integration in data['integrations']:
    print(f"{integration['platform']}: {integration['username']} ({integration['id']})")
```

```php PHP theme={"system"}
<?php
$ch = curl_init('https://public.reap.video/api/v1/automation/get-integrations');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: Bearer YOUR_API_KEY',
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
$data = json_decode($response, true);
foreach ($data['integrations'] as $integration) {
    echo $integration['platform'] . ': ' . $integration['username'] . "\n";
}
?>
```

```go Go theme={"system"}
package main
import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)
type Integration struct {
    ID       string `json:"id"`
    Platform string `json:"platform"`
    Username string `json:"username"`
}
type Response struct {
    Integrations []Integration `json:"integrations"`
}
func main() {
    url := "https://public.reap.video/api/v1/automation/get-integrations"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    var result Response
    json.Unmarshal(body, &result)
    for _, i := range result.Integrations {
        fmt.Printf("%s: %s (%s)\n", i.Platform, i.Username, i.ID)
    }
}
```

```java Java theme={"system"}
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
public class GetIntegrationsExample {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://public.reap.video/api/v1/automation/get-integrations");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Authorization", "Bearer YOUR_API_KEY");
        conn.setRequestProperty("Content-Type", "application/json");
        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
        StringBuilder response = new StringBuilder();
        String responseLine;
        while ((responseLine = br.readLine()) != null) {
            response.append(responseLine.trim());
        }
        System.out.println(response.toString());
    }
}
```

## Example Response

**200 OK**

```json theme={"system"}
{
  "integrations": [
    {
      "id": "66a1b2c3d4e5f6a7b8c9d0e1",
      "platform": "youtube",
      "isActive": true,
      "username": "@mychannel",
      "name": "My YouTube Channel",
      "profilePictureUrl": "https://yt3.googleusercontent.com/example.jpg"
    },
    {
      "id": "66a1b2c3d4e5f6a7b8c9d0e2",
      "platform": "instagram",
      "isActive": true,
      "username": "myaccount",
      "name": "My Instagram",
      "profilePictureUrl": "https://instagram.com/example.jpg"
    },
    {
      "id": "66a1b2c3d4e5f6a7b8c9d0e3",
      "platform": "tiktok",
      "isActive": true,
      "username": "@mytiktok",
      "name": "My TikTok",
      "profilePictureUrl": "https://p16-sign.tiktokcdn.com/example.jpg"
    }
  ]
}
```

**401 Unauthorized**

```json theme={"system"}
{
  "detail": "Unauthorized - Invalid or missing API key"
}
```

**429 Too Many Requests**

```json theme={"system"}
{
  "error": "Rate limit exceeded: 60 per 1 minute"
}
```


## OpenAPI

````yaml GET /automation/get-integrations
openapi: 3.1.0
info:
  title: Reap Automation API
  description: AI-powered video processing automation API
  version: 1.0.0
servers:
  - url: https://public.reap.video/api/v1
security:
  - bearerAuth: []
paths:
  /automation/get-integrations:
    get:
      summary: Get Integrations
      description: List all active social media integrations
      operationId: getIntegrations
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GetIntegrationsResponse'
components:
  schemas:
    GetIntegrationsResponse:
      type: object
      properties:
        integrations:
          type: array
          items:
            $ref: '#/components/schemas/AutomationIntegration'
    AutomationIntegration:
      type: object
      properties:
        id:
          type: string
        platform:
          type: string
          enum:
            - youtube
            - instagram
            - tiktok
            - linkedin
            - x
        isActive:
          type: boolean
        username:
          type: string
          nullable: true
        name:
          type: string
          nullable: true
        profilePictureUrl:
          type: string
          nullable: true
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.