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

# Get Vimeo Connection by ID

> Retrieve details of a specific Vimeo connection

## Overview

Retrieve detailed information about a specific Vimeo connection using its unique identifier. For security, sensitive credentials (client secret and access token) are excluded from the response. The connection must belong to your account.

<Note>
  You need a valid API key to use this endpoint. Get your API key from the [API Access page](https://app.pictory.ai/api-access) in your Pictory dashboard.
</Note>

***

## API Endpoint

```http theme={null}
GET https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{connectionid}
```

***

## Request Parameters

### Headers

<ParamField header="Authorization" type="string" required>
  API key for authentication (starts with `pictai_`)

  ```
  Authorization: YOUR_API_KEY
  ```
</ParamField>

### Path Parameters

<ParamField path="connectionid" type="string" required>
  The unique identifier of the Vimeo connection to retrieve

  **Example:** `"20251222155613307xv0nodhitf9cd0f"`
</ParamField>

***

## Response

Returns the Vimeo connection object with all configuration details including `connectionId`, `name`, `description`, `clientIdentifier`, `type`, `enabled` status, `createdDate`, `updatedDate`, and `version` number. For security, sensitive credentials (`clientSecret` and `accessToken`) are never returned in API responses.

### Response Examples

<ResponseExample>
  ```json 200 - Success theme={null}
  {
    "connectionId": "20251222155613307xv0nodhitf9cd0f",
    "name": "Test Vimeo Connection",
    "description": "Testing Vimeo connection via API",
    "clientIdentifier": "test_client_id_123",
    "type": "VIMEO",
    "enabled": true,
    "createdDate": "2025-12-22T15:56:12.309Z",
    "updatedDate": "2025-12-22T15:56:12.309Z",
    "version": 1
  }
  ```

  ```json 401 - Unauthorized theme={null}
  {
    "message": "Unauthorized"
  }
  ```

  ```json 404 - Not Found theme={null}
  {
    "message": "Connection not found"
  }
  ```

  ```json 500 - Internal Server Error theme={null}
  {
    "error": {
      "code": "INTERNAL_ERROR",
      "message": "An unexpected error occurred"
    }
  }
  ```
</ResponseExample>

***

## Code Examples

<Tip>
  Replace `YOUR_API_KEY` with your actual API key that starts with `pictai_`
</Tip>

<CodeGroup>
  ```bash cURL theme={null}
  # Retrieve a specific Vimeo connection by ID
  # Replace YOUR_API_KEY with your actual API key
  # Replace CONNECTION_ID with the actual connection ID

  curl --request GET \
    --url https://api.pictory.ai/pictoryapis/v1/vimeo-connections/CONNECTION_ID \
    --header 'Authorization: YOUR_API_KEY' | python -m json.tool
  ```

  ```javascript JavaScript / Node.js theme={null}
  // Replace 'YOUR_API_KEY' with your actual API key

  const getVimeoConnectionById = async (apiKey, connectionId) => {
    const response = await fetch(`https://api.pictory.ai/pictoryapis/v1/vimeo-connections/${connectionId}`, {
      method: 'GET',
      headers: {
        'Authorization': `${apiKey}`
      }
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Failed: ${error.message}`);
    }

    return await response.json();
  };

  // Usage
  try {
    const connectionId = '20251222155613307xv0nodhitf9cd0f';
    const connection = await getVimeoConnectionById('YOUR_API_KEY', connectionId);
    console.log('Connection Details:', connection);
    console.log('Connection Name:', connection.name);
    console.log('Is Enabled:', connection.enabled);
    console.log('Version:', connection.version);
  } catch (error) {
    console.error('Error:', error.message);
  }
  ```

  ```python Python theme={null}
  # Replace 'YOUR_API_KEY' with your actual API key

  import requests

  def get_vimeo_connection_by_id(api_key, connection_id):
      """Retrieve a specific Vimeo connection by ID"""
      url = f"https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{connection_id}"

      headers = {
          "Authorization": api_key
      }

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

      return response.json()

  # Usage
  try:
      connection_id = "20251222155613307xv0nodhitf9cd0f"
      connection = get_vimeo_connection_by_id("YOUR_API_KEY", connection_id)
      print(f"Connection Details: {connection}")
      print(f"Connection Name: {connection['name']}")
      print(f"Is Enabled: {connection['enabled']}")
      print(f"Version: {connection['version']}")
  except requests.exceptions.HTTPError as e:
      error = e.response.json()
      print(f"Error: {error.get('message', 'Request failed')}")
  ```

  ```php PHP theme={null}
  <?php
  // Replace 'YOUR_API_KEY' with your actual API key

  function getVimeoConnectionById($apiKey, $connectionId) {
      $url = "https://api.pictory.ai/pictoryapis/v1/vimeo-connections/{$connectionId}";

      $ch = curl_init($url);
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
      curl_setopt($ch, CURLOPT_HTTPHEADER, [
          'Authorization: ' . $apiKey
      ]);

      $response = curl_exec($ch);
      $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
      curl_close($ch);

      if ($httpCode !== 200) {
          $error = json_decode($response, true);
          throw new Exception($error['message'] ?? 'Request failed');
      }

      return json_decode($response, true);
  }

  // Usage
  try {
      $connectionId = '20251222155613307xv0nodhitf9cd0f';
      $connection = getVimeoConnectionById('YOUR_API_KEY', $connectionId);
      echo "Connection Details:\n";
      print_r($connection);
      echo "Connection Name: " . $connection['name'] . "\n";
      echo "Is Enabled: " . ($connection['enabled'] ? 'Yes' : 'No') . "\n";
      echo "Version: " . $connection['version'] . "\n";
  } catch (Exception $e) {
      echo "Error: " . $e->getMessage() . "\n";
  }
  ?>
  ```

  ```go Go theme={null}
  // Replace "YOUR_API_KEY" with your actual API key

  package main

  import (
      "encoding/json"
      "fmt"
      "io"
      "net/http"
  )

  type VimeoConnection struct {
      ConnectionID     string `json:"connectionId"`
      Name             string `json:"name"`
      Description      string `json:"description"`
      ClientIdentifier string `json:"clientIdentifier"`
      Type             string `json:"type"`
      Enabled          bool   `json:"enabled"`
      CreatedDate      string `json:"createdDate"`
      UpdatedDate      string `json:"updatedDate"`
      Version          int    `json:"version"`
  }

  func getVimeoConnectionById(apiKey string, connectionId string) (*VimeoConnection, error) {
      url := fmt.Sprintf("https://api.pictory.ai/pictoryapis/v1/vimeo-connections/%s", connectionId)

      req, err := http.NewRequest("GET", url, nil)
      if err != nil {
          return nil, err
      }

      req.Header.Set("Authorization", apiKey)

      client := &http.Client{}
      resp, err := client.Do(req)
      if err != nil {
          return nil, err
      }
      defer resp.Body.Close()

      body, err := io.ReadAll(resp.Body)
      if err != nil {
          return nil, err
      }

      if resp.StatusCode != http.StatusOK {
          return nil, fmt.Errorf("request failed (status %d): %s", resp.StatusCode, string(body))
      }

      var result VimeoConnection
      if err := json.Unmarshal(body, &result); err != nil {
          return nil, err
      }

      return &result, nil
  }

  // Usage
  func main() {
      connectionId := "20251222155613307xv0nodhitf9cd0f"
      connection, err := getVimeoConnectionById("YOUR_API_KEY", connectionId)
      if err != nil {
          panic(err)
      }

      fmt.Printf("Connection Details: %+v\n", connection)
      fmt.Printf("Connection Name: %s\n", connection.Name)
      fmt.Printf("Is Enabled: %t\n", connection.Enabled)
      fmt.Printf("Version: %d\n", connection.Version)
  }
  ```
</CodeGroup>

***

## Error Handling

<AccordionGroup>
  <Accordion title="401 Unauthorized" icon="lock">
    **Cause:** Invalid or missing API key

    **Solution:**

    * Verify your API key is correct and starts with `pictai_`
    * Check the `Authorization` header is properly formatted: `YOUR_API_KEY`
    * Ensure your API key hasn't expired
    * Get a new API key from the [API Access page](https://app.pictory.ai/api-access)
  </Accordion>

  <Accordion title="404 Not Found" icon="circle-xmark">
    **Cause:** The connection ID does not exist or you do not have access to it

    **Solution:**

    * Verify the connection ID is correct and complete
    * Ensure the connection belongs to your account
    * Check if the connection has been deleted
    * Connection IDs are case-sensitive - confirm the exact casing
    * Use the [Get Vimeo Connections](/api-reference/vimeo-integration/get-vimeo-connections) endpoint to list all your connections
  </Accordion>

  <Accordion title="Unexpected Connection Details" icon="triangle-exclamation">
    **Cause:** The returned connection details do not match expectations

    **Solution:**

    * Double-check the connection ID in the URL path
    * Verify you are using the correct API key for the account that owns the connection
    * Ensure you have not confused this connection with another one
    * Check if the connection was recently updated by someone else
  </Accordion>
</AccordionGroup>