> ## 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](/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 is rate limited to 10 requests per minute per API key.

<Note>
  Integrations are connected and managed from your Reap dashboard. This endpoint only lists your active integrations.
</Note>

## Response

<ResponseField name="integrations" type="array">
  Array of active integration objects

  <Expandable title="Integration Object">
    <ResponseField name="id" type="string">
      Unique integration identifier (use this when publishing or scheduling)
    </ResponseField>

    <ResponseField name="platform" type="string">
      Social media platform

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

    <ResponseField name="isActive" type="boolean">
      Whether the integration is currently active and ready to publish
    </ResponseField>

    <ResponseField name="username" type="string">
      Platform username or handle
    </ResponseField>

    <ResponseField name="name" type="string">
      Display name on the platform
    </ResponseField>

    <ResponseField name="profilePictureUrl" type="string">
      URL of the profile picture on the platform
    </ResponseField>
  </Expandable>
</ResponseField>

## Example Request

<CodeGroup>
  ```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());
      }
  }
  ```
</CodeGroup>

## Example Response

<CodeGroup>
  <CodeGroup.Tab label="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"
        }
      ]
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="401 Unauthorized">
    ```json theme={"system"}
    {
      "detail": "Unauthorized - Invalid or missing API key"
    }
    ```
  </CodeGroup.Tab>

  <CodeGroup.Tab label="429 Too Many Requests">
    ```json theme={"system"}
    {
      "detail": "Too Many Requests - Rate limit of 10 requests per minute exceeded"
    }
    ```
  </CodeGroup.Tab>
</CodeGroup>


## 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

````