> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.pinnacle.sh/v-2/api-reference/rcs-agents/get-capabilities/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.pinnacle.sh/_mcp/server.

# Get RCS Capabilities

POST https://api.pinnacle.sh/rcs/capabilities
Content-Type: application/json

Check RCS capabilities for one or more phone numbers.

This endpoint allows you to verify which RCS features (cards, buttons, etc.) are supported
on specific phone numbers before sending RCS messages to them.


Reference: https://docs.pinnacle.sh/api-reference/rcs-agents/get-capabilities

## Authentication

- `PINNACLE-API-KEY` header (required) — API Key authentication via header

## Request

### Body (application/json)

This endpoint expects a RcsCapabilitiesRequest.

- `phoneNumbers` (list of string, required) — List of phone numbers to check RCS capabilities for (E.164 format).  **Limit:** 1 min
- `agentId` (string, optional) — Optional RCS agent ID (prefixed with 'agent_') to check capabilities of a number from a specific agent.

## Response

### 200

Returns RCS capabilities for each requested phone number. The response is a map where keys are phone numbers and values are either: - `null` if the number doesn't support RCS - An object containing supported cards and actions if RCS is supported

- `map from string to RcsCapability`

## Errors

### 400 Bad Request Error

Validation failed. The payload has missing required fields and/or invalid types.  See [https://zod.dev/error-formatting](https://zod.dev/error-formatting) for more information.

- `description` (string, required) — Human-readable summary of validation failures.
- `errors` (ZodErrorErrors, required) — Structured dictionary of issues containing two main sections: - `errors`: Array of global validation errors not tied to specific fields - `properties`: Object mapping field names to their specific validation errors, where each field contains an `errors` array

### 401 Unauthorized Error

The request lacks valid authentication credentials or the provided credentials are invalid.  Ensure you're including a valid API key in the request headers and that your account has the necessary permissions to access this endpoint.

- `error` (string, required) — Human-readable description of the error that occurred, corresponding to the HTTP status code.

### 403 Forbidden Error

Your subscription does not include access to this feature.  This occurs when attempting to use functionality that requires a higher subscription tier. Please upgrade your subscription to access this feature.

- `error` (string, required) — Human-readable description of the error that occurred, corresponding to the HTTP status code.

### 500 Internal Server Error

An unexpected error occurred on Pinnacle's servers while processing your request.  If this error persists, please contact support with the request details.

- `error` (string, required) — Human-readable description of the error that occurred, corresponding to the HTTP status code.

### 501 Not Implemented Error

The requested functionality is not implemented on the server.  This typically indicates that the feature or endpoint you attempted to access is unavailable or not yet supported.

- `error` (string, required) — Human-readable description of the error that occurred, corresponding to the HTTP status code.

## Types

### RcsCapability

RCS capabilities for a phone number

- `cards` (RcsCapabilityCards, required)
- `actions` (RcsCapabilityActions, required) — Supported button action types inside the rich cards or quick replies. Each key is a button action type that defines a specific button type in the Pinnacle API.

### ZodErrorErrors

Structured dictionary of issues containing two main sections: - `errors`: Array of global validation errors not tied to specific fields - `properties`: Object mapping field names to their specific validation errors, where each field contains an `errors` array

### RcsCapabilityCards

- `standalone` (boolean, required) — Whether the phone number supports standalone rich cards (`cards.length == 1`)
- `carousel` (boolean, required) — Whether the phone number supports carousel rich cards

### RcsCapabilityActions

Supported button action types inside the rich cards or quick replies. Each key is a button action type that defines a specific button type in the Pinnacle API.

- `openUrl` (boolean, required) — Buttons that open URLs are supported
- `call` (boolean, required) — Buttons that make phone calls are supported
- `trigger` (boolean, required) — Buttons that trigger actions are supported
- `requestUserLocation` (boolean, required) — Buttons that request user location are supported
- `scheduleEvent` (boolean, required) — Buttons are supported
- `sendLocation` (boolean, required) — Buttons that send location are supported

## Examples

### RCS Capabilities

**Response**

```json
{
  "+12345678901": {
    "cards": {
      "standalone": true,
      "carousel": true
    },
    "actions": {
      "openUrl": true,
      "call": true,
      "trigger": true,
      "requestUserLocation": true,
      "scheduleEvent": false,
      "sendLocation": false
    }
  },
  "+19876543210": null
}
```

**SDK Code**

```python RCS Capabilities
import requests

url = "https://api.pinnacle.sh/rcs/capabilities"

headers = {"PINNACLE-API-KEY": "<apiKey>"}

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

print(response.json())
```

```javascript RCS Capabilities
const url = 'https://api.pinnacle.sh/rcs/capabilities';
const options = {method: 'POST', headers: {'PINNACLE-API-KEY': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go RCS Capabilities
package main

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

func main() {

	url := "https://api.pinnacle.sh/rcs/capabilities"

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

	req.Header.Add("PINNACLE-API-KEY", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby RCS Capabilities
require 'uri'
require 'net/http'

url = URI("https://api.pinnacle.sh/rcs/capabilities")

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

request = Net::HTTP::Post.new(url)
request["PINNACLE-API-KEY"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

```java RCS Capabilities
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.pinnacle.sh/rcs/capabilities")
  .header("PINNACLE-API-KEY", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.pinnacle.sh/rcs/capabilities', [
  'headers' => [
    'PINNACLE-API-KEY' => '<apiKey>',
  ],
]);

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

```csharp RCS Capabilities
using RestSharp;

var client = new RestClient("https://api.pinnacle.sh/rcs/capabilities");
var request = new RestRequest(Method.POST);
request.AddHeader("PINNACLE-API-KEY", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift RCS Capabilities
import Foundation

let headers = ["PINNACLE-API-KEY": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.pinnacle.sh/rcs/capabilities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

### rcs_getCapabilities_example

**Request**

```json
{
  "phoneNumbers": [
    "+12345678901",
    "+19876543210"
  ]
}
```

**Response**

```json
{
  "+12345678901": {
    "cards": {
      "standalone": true,
      "carousel": true
    },
    "actions": {
      "openUrl": true,
      "call": true,
      "trigger": true,
      "requestUserLocation": true,
      "scheduleEvent": false,
      "sendLocation": false
    }
  },
  "+19876543210": null
}
```

**SDK Code**

```python rcs_getCapabilities_example
import requests

url = "https://api.pinnacle.sh/rcs/capabilities"

payload = { "phoneNumbers": ["+12345678901", "+19876543210"] }
headers = {
    "PINNACLE-API-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript rcs_getCapabilities_example
const url = 'https://api.pinnacle.sh/rcs/capabilities';
const options = {
  method: 'POST',
  headers: {'PINNACLE-API-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"phoneNumbers":["+12345678901","+19876543210"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go rcs_getCapabilities_example
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.pinnacle.sh/rcs/capabilities"

	payload := strings.NewReader("{\n  \"phoneNumbers\": [\n    \"+12345678901\",\n    \"+19876543210\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("PINNACLE-API-KEY", "<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 rcs_getCapabilities_example
require 'uri'
require 'net/http'

url = URI("https://api.pinnacle.sh/rcs/capabilities")

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

request = Net::HTTP::Post.new(url)
request["PINNACLE-API-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"phoneNumbers\": [\n    \"+12345678901\",\n    \"+19876543210\"\n  ]\n}"

response = http.request(request)
puts response.read_body
```

```java rcs_getCapabilities_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.pinnacle.sh/rcs/capabilities")
  .header("PINNACLE-API-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"phoneNumbers\": [\n    \"+12345678901\",\n    \"+19876543210\"\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.pinnacle.sh/rcs/capabilities', [
  'body' => '{
  "phoneNumbers": [
    "+12345678901",
    "+19876543210"
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'PINNACLE-API-KEY' => '<apiKey>',
  ],
]);

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

```csharp rcs_getCapabilities_example
using RestSharp;

var client = new RestClient("https://api.pinnacle.sh/rcs/capabilities");
var request = new RestRequest(Method.POST);
request.AddHeader("PINNACLE-API-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"phoneNumbers\": [\n    \"+12345678901\",\n    \"+19876543210\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift rcs_getCapabilities_example
import Foundation

let headers = [
  "PINNACLE-API-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["phoneNumbers": ["+12345678901", "+19876543210"]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.pinnacle.sh/rcs/capabilities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```

> One API for RCS, iMessage, MMS, and SMS. Build, test, and scale every channel — send your first message in minutes, not weeks.