RCS API

RCS (Rich Communication Services) is the evolution of smartphone messaging. Unlike SMS, it enables multimedia content, Call to Action buttons (CTA), and bidirectional conversations with a verified sender called an RCS Agent.

Why use RCS

Visible brand: RCS Agent name and icons
Rich content: text, images, cards, and carousels
Interactive buttons: links, calls, guided replies
Two-way conversation: manage and respond to user interactions

Use cases

Rich notifications with images and buttons
Promotions, offers, and shopping carts (cards/carousels)
Conversational customer support
Campaigns with high engagement

User requirements

Compatible smartphone and messaging app with RCS support; active internet connection.

Core concepts

Message types

TEXT: text message with optional buttons
CARD: single rich card with image, title, description, and actions
CAROUSEL: scrollable list of 2-10 cards for catalogs or menus

Suggestions (CTA)

Action buttons users can select:

reply: guided text response
url: link opening
dial: phone call initiation
coordinates: coordinate sharing
location: location search
calendar: calendar event creation

Media

Cards support images. Provide public, valid URLs for the entire send duration. Always set an appropriate height value.

Placeholders

Use variables in text (e.g., \{name\}). If you don't provide values during send, the variable appears unsubstituted.

SMS Fallback

Optional. If a contact isn't reachable via RCS, send a fallback SMS instead (sender must be authorized).

Authentication and security

Protocol: HTTPS required
Authentication: API Key in header (e.g., X-Api-Key)

Quickstart

Get up and running in three steps:

List RCS agents to find your agent ID
Send a message using a template or free-form content
Receive outcomes via webhook for Delivery/Read events and handle Inbound responses

Template guide

For the complete JSON body structure of templates (TEXT, CARD, CAROUSEL), Suggestions, Media, Placeholders, and SMS Fallback, see RCS Templates.

RCS Agents

List agents

Retrieve all RCS agents configured for your account. You'll need an agentId to send any message.

curl -X GET https://lora-api.agiletelecom.com/api/message-server/rcs/agents \
  -H "X-Api-Key: YOUR_API_KEY"

import requests

headers = {
    "X-Api-Key": "YOUR_API_KEY"
}

response = requests.get(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/agents",
    headers=headers
)
print(response.json())

const fetch = require('node-fetch');

const headers = {
    'X-Api-Key': 'YOUR_API_KEY'
};

fetch('https://lora-api.agiletelecom.com/api/message-server/rcs/agents', {
    method: 'GET',
    headers: headers
})
.then(response => response.json())
.then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/agents";
$headers = array(
    "X-Api-Key: YOUR_API_KEY"
);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

echo json_decode($response, true);
?>

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/agents"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

try
{
    var response = await client.GetAsync("https://lora-api.agiletelecom.com/api/message-server/rcs/agents");
    var content = await response.Content.ReadAsStringAsync();
    Console.WriteLine(content);
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

package main

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

func main() {
	client := &http.Client{}
	req, _ := http.NewRequest("GET", "https://lora-api.agiletelecom.com/api/message-server/rcs/agents", nil)
	req.Header.Add("X-Api-Key", "YOUR_API_KEY")
	
	resp, _ := client.Do(req)
	defer resp.Body.Close()
	
	body, _ := ioutil.ReadAll(resp.Body)
	fmt.Println(string(body))
}

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/agents")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"

response = http.request(request)
puts JSON.parse(response.body)

Response: An array of agent objects with the agentId field. Copy the agentId you want to use for sending messages.

RCS Templates (CRUD)

Templates let you reuse message designs across campaigns. Store them once, send thousands of times. See RCS Templates for the complete JSON structure.

List templates

Retrieve all templates for your account in paginated format. Useful for building a template picker in your UI.

curl -X GET "https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1" \
  -H "X-Api-Key: YOUR_API_KEY"

import requests

headers = {"X-Api-Key": "YOUR_API_KEY"}
params = {"limit": 10, "page": 1}

response = requests.get(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates",
    headers=headers,
    params=params
)
print(response.json())

const fetch = require('node-fetch');

const headers = { 'X-Api-Key': 'YOUR_API_KEY' };
const url = 'https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1';

fetch(url, { method: 'GET', headers })
    .then(r => r.json())
    .then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1";
$headers = ["X-Api-Key: YOUR_API_KEY"];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true
]);

$response = curl_exec($ch);
curl_close($ch);
echo json_decode($response, true);
?>

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var response = await client.GetAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1"
);
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

client := &http.Client{}
req, _ := http.NewRequest("GET", 
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1", 
    nil)
req.Header.Add("X-Api-Key", "YOUR_API_KEY")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/templates?limit=10&page=1")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"

response = http.request(request)
puts JSON.parse(response.body)

Parameters:

limit: number of records per page (e.g., 10)
page: page number (starts at 1)

Get template details

Fetch a single template by ID to see its complete structure before sending. Helpful for previewing template content or validating placeholders.

curl -X GET https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123 \
  -H "X-Api-Key: YOUR_API_KEY"

import requests

headers = {"X-Api-Key": "YOUR_API_KEY"}
template_id = "tpl_123"

response = requests.get(
    f"https://lora-api.agiletelecom.com/api/message-server/rcs/templates/{template_id}",
    headers=headers
)
print(response.json())

const fetch = require('node-fetch');

const headers = { 'X-Api-Key': 'YOUR_API_KEY' };
const templateId = 'tpl_123';

fetch(`https://lora-api.agiletelecom.com/api/message-server/rcs/templates/${templateId}`, 
    { method: 'GET', headers })
    .then(r => r.json())
    .then(data => console.log(data));

<?php
$templateId = "tpl_123";
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/{$templateId}";
$headers = ["X-Api-Key: YOUR_API_KEY"];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true
]);

echo json_decode(curl_exec($ch), true);
curl_close($ch);
?>

String templateId = "tpl_123";
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/templates/" + templateId))
    .header("X-Api-Key", "YOUR_API_KEY")
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var response = await client.GetAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123"
);
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

client := &http.Client{}
req, _ := http.NewRequest("GET", 
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123", 
    nil)
req.Header.Add("X-Api-Key", "YOUR_API_KEY")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"

response = http.request(request)
puts JSON.parse(response.body)

Create template

Store a reusable template for sending the same message to many recipients. See RCS Templates for body structure details.

curl -X POST https://lora-api.agiletelecom.com/api/message-server/rcs/templates \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Welcome Template",
    "type": "TEXT",
    "body": { "text": "Welcome to our service!" }
  }'

import requests

headers = {
    "X-Api-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
body = {
    "name": "Welcome Template",
    "type": "TEXT",
    "body": {"text": "Welcome to our service!"}
}

response = requests.post(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates",
    headers=headers,
    json=body
)
print(response.json())

const fetch = require('node-fetch');

const headers = {
    'X-Api-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
};

const body = {
    name: 'Welcome Template',
    type: 'TEXT',
    body: { text: 'Welcome to our service!' }
};

fetch('https://lora-api.agiletelecom.com/api/message-server/rcs/templates', {
    method: 'POST',
    headers,
    body: JSON.stringify(body)
})
.then(r => r.json())
.then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/templates";
$headers = [
    "X-Api-Key: YOUR_API_KEY",
    "Content-Type: application/json"
];

$payload = [
    "name" => "Welcome Template",
    "type" => "TEXT",
    "body" => ["text" => "Welcome to our service!"]
];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

echo json_decode(curl_exec($ch), true);
curl_close($ch);
?>

String jsonPayload = """
{
  "name": "Welcome Template",
  "type": "TEXT",
  "body": { "text": "Welcome to our service!" }
}
""";

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/templates"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var payload = new
{
    name = "Welcome Template",
    type = "TEXT",
    body = new { text = "Welcome to our service!" }
};

var content = new StringContent(
    JsonSerializer.Serialize(payload),
    Encoding.UTF8,
    "application/json"
);

var response = await client.PostAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates",
    content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());

payload := `{
  "name": "Welcome Template",
  "type": "TEXT",
  "body": { "text": "Welcome to our service!" }
}`

client := &http.Client{}
req, _ := http.NewRequest("POST", 
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates",
    strings.NewReader(payload))

req.Header.Add("X-Api-Key", "YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/templates")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

payload = {
    name: 'Welcome Template',
    type: 'TEXT',
    body: { text: 'Welcome to our service!' }
}

request = Net::HTTP::Post.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.generate(payload)

response = http.request(request)
puts JSON.parse(response.body)

Update template

Modify an existing template. All subsequent sends using this template will use the updated content.

curl -X PUT https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123 \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated Welcome Template",
    "type": "TEXT",
    "body": { "text": "Welcome back!" }
  }'

import requests

headers = {
    "X-Api-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
    "name": "Updated Welcome Template",
    "type": "TEXT",
    "body": {"text": "Welcome back!"}
}

response = requests.put(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123",
    headers=headers,
    json=payload
)
print(response.json())

const fetch = require('node-fetch');

const headers = {
    'X-Api-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
};

const payload = {
    name: 'Updated Welcome Template',
    type: 'TEXT',
    body: { text: 'Welcome back!' }
};

fetch('https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123', {
    method: 'PUT',
    headers,
    body: JSON.stringify(payload)
})
.then(r => r.json())
.then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123";
$headers = [
    "X-Api-Key: YOUR_API_KEY",
    "Content-Type: application/json"
];

$payload = [
    "name" => "Updated Welcome Template",
    "type" => "TEXT",
    "body" => ["text" => "Welcome back!"]
];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_CUSTOMREQUEST => "PUT",
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

echo json_decode(curl_exec($ch), true);
curl_close($ch);
?>

String jsonPayload = """
{
  "name": "Updated Welcome Template",
  "type": "TEXT",
  "body": { "text": "Welcome back!" }
}
""";

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var payload = new
{
    name = "Updated Welcome Template",
    type = "TEXT",
    body = new { text = "Welcome back!" }
};

var content = new StringContent(
    JsonSerializer.Serialize(payload),
    Encoding.UTF8,
    "application/json"
);

var response = await client.PutAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123",
    content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());

payload := `{
  "name": "Updated Welcome Template",
  "type": "TEXT",
  "body": { "text": "Welcome back!" }
}`

client := &http.Client{}
req, _ := http.NewRequest("PUT",
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123",
    strings.NewReader(payload))

req.Header.Add("X-Api-Key", "YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

payload = {
    name: 'Updated Welcome Template',
    type: 'TEXT',
    body: { text: 'Welcome back!' }
}

request = Net::HTTP::Put.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.generate(payload)

response = http.request(request)
puts JSON.parse(response.body)

Delete template

Remove a template from your account. Messages already sent won't be affected, but you won't be able to send new messages using this template.

curl -X DELETE https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123 \
  -H "X-Api-Key: YOUR_API_KEY"

import requests

headers = {"X-Api-Key": "YOUR_API_KEY"}

response = requests.delete(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123",
    headers=headers
)
print(response.status_code)

const fetch = require('node-fetch');

const headers = { 'X-Api-Key': 'YOUR_API_KEY' };

fetch('https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123', {
    method: 'DELETE',
    headers
})
.then(r => console.log(r.status));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123";
$headers = ["X-Api-Key: YOUR_API_KEY"];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_CUSTOMREQUEST => "DELETE",
    CURLOPT_RETURNTRANSFER => true
]);

echo curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
?>

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .DELETE()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var response = await client.DeleteAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123"
);
Console.WriteLine((int)response.StatusCode);

client := &http.Client{}
req, _ := http.NewRequest("DELETE",
    "https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123",
    nil)

req.Header.Add("X-Api-Key", "YOUR_API_KEY")

resp, _ := client.Do(req)
fmt.Println(resp.StatusCode)

require 'net/http'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/templates/tpl_123")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"

response = http.request(request)
puts response.code

Sending messages

Send from template

Send a message using a previously saved template. Use messageId to track delivery reports and read events. Optionally schedule the send for a future date.

curl -X POST https://lora-api.agiletelecom.com/api/message-server/rcs/send \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "templateId": "tpl_123",
    "destination": "+391234567890",
    "agentId": "agent_abc",
    "messageId": "ext-unique-id-001",
    "placeholders": {"name": "Anna"},
    "simulation": false,
    "scheduledDate": "2026-04-15T10:30:00Z"
  }'

import requests
from datetime import datetime

headers = {
    "X-Api-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

payload = {
    "templateId": "tpl_123",
    "destination": "+391234567890",
    "agentId": "agent_abc",
    "messageId": "ext-unique-id-001",
    "placeholders": {"name": "Anna"},
    "simulation": False,
    "scheduledDate": "2026-04-15T10:30:00Z"
}

response = requests.post(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/send",
    headers=headers,
    json=payload
)
print(response.json())

const fetch = require('node-fetch');

const headers = {
    'X-Api-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
};

const payload = {
    templateId: 'tpl_123',
    destination: '+391234567890',
    agentId: 'agent_abc',
    messageId: 'ext-unique-id-001',
    placeholders: { name: 'Anna' },
    simulation: false,
    scheduledDate: '2026-04-15T10:30:00Z'
};

fetch('https://lora-api.agiletelecom.com/api/message-server/rcs/send', {
    method: 'POST',
    headers,
    body: JSON.stringify(payload)
})
.then(r => r.json())
.then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/send";
$headers = [
    "X-Api-Key: YOUR_API_KEY",
    "Content-Type: application/json"
];

$payload = [
    "templateId" => "tpl_123",
    "destination" => "+391234567890",
    "agentId" => "agent_abc",
    "messageId" => "ext-unique-id-001",
    "placeholders" => ["name" => "Anna"],
    "simulation" => false,
    "scheduledDate" => "2026-04-15T10:30:00Z"
];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

echo json_decode(curl_exec($ch), true);
curl_close($ch);
?>

String jsonPayload = """
{
  "templateId": "tpl_123",
  "destination": "+391234567890",
  "agentId": "agent_abc",
  "messageId": "ext-unique-id-001",
  "placeholders": { "name": "Anna" },
  "simulation": false,
  "scheduledDate": "2026-04-15T10:30:00Z"
}
""";

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/send"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var payload = new
{
    templateId = "tpl_123",
    destination = "+391234567890",
    agentId = "agent_abc",
    messageId = "ext-unique-id-001",
    placeholders = new { name = "Anna" },
    simulation = false,
    scheduledDate = "2026-04-15T10:30:00Z"
};

var content = new StringContent(
    JsonSerializer.Serialize(payload),
    Encoding.UTF8,
    "application/json"
);

var response = await client.PostAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/send",
    content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());

payload := `{
  "templateId": "tpl_123",
  "destination": "+391234567890",
  "agentId": "agent_abc",
  "messageId": "ext-unique-id-001",
  "placeholders": { "name": "Anna" },
  "simulation": false,
  "scheduledDate": "2026-04-15T10:30:00Z"
}`

client := &http.Client{}
req, _ := http.NewRequest("POST",
    "https://lora-api.agiletelecom.com/api/message-server/rcs/send",
    strings.NewReader(payload))

req.Header.Add("X-Api-Key", "YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/send")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

payload = {
    templateId: 'tpl_123',
    destination: '+391234567890',
    agentId: 'agent_abc',
    messageId: 'ext-unique-id-001',
    placeholders: { name: 'Anna' },
    simulation: false,
    scheduledDate: '2026-04-15T10:30:00Z'
}

request = Net::HTTP::Post.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.generate(payload)

response = http.request(request)
puts JSON.parse(response.body)

Field	Type	Required	Description
templateId	string	Yes	Template ID to use
destination	string	Yes	Recipient phone number
agentId	string	Yes	RCS Agent ID
messageId	string	Yes	Unique identifier for idempotency
placeholders	object	No	Variables to replace in template
simulation	boolean	No	Test mode (default: false)
scheduledDate	string (ISO-8601)	No	Scheduled send date/time

Send without template (free-form)

Send a message on-the-fly without storing it as a template. Useful for dynamic or one-off messages.

curl -X POST https://lora-api.agiletelecom.com/api/message-server/rcs/send \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agentId": "agent_abc",
    "destination": "+391234567890",
    "messageId": "ext-unique-id-002",
    "body": {
      "type": "TEXT",
      "text": "Your order #12345 is ready for pickup!"
    }
  }'

import requests

headers = {
    "X-Api-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

payload = {
    "agentId": "agent_abc",
    "destination": "+391234567890",
    "messageId": "ext-unique-id-002",
    "body": {
        "type": "TEXT",
        "text": "Your order #12345 is ready for pickup!"
    }
}

response = requests.post(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/send",
    headers=headers,
    json=payload
)
print(response.json())

const fetch = require('node-fetch');

const headers = {
    'X-Api-Key': 'YOUR_API_KEY',
    'Content-Type': 'application/json'
};

const payload = {
    agentId: 'agent_abc',
    destination: '+391234567890',
    messageId: 'ext-unique-id-002',
    body: {
        type: 'TEXT',
        text: 'Your order #12345 is ready for pickup!'
    }
};

fetch('https://lora-api.agiletelecom.com/api/message-server/rcs/send', {
    method: 'POST',
    headers,
    body: JSON.stringify(payload)
})
.then(r => r.json())
.then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/message-server/rcs/send";
$headers = [
    "X-Api-Key: YOUR_API_KEY",
    "Content-Type: application/json"
];

$payload = [
    "agentId" => "agent_abc",
    "destination" => "+391234567890",
    "messageId" => "ext-unique-id-002",
    "body" => [
        "type" => "TEXT",
        "text" => "Your order #12345 is ready for pickup!"
    ]
];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode($payload),
    CURLOPT_RETURNTRANSFER => true
]);

echo json_decode(curl_exec($ch), true);
curl_close($ch);
?>

String jsonPayload = """
{
  "agentId": "agent_abc",
  "destination": "+391234567890",
  "messageId": "ext-unique-id-002",
  "body": {
    "type": "TEXT",
    "text": "Your order #12345 is ready for pickup!"
  }
}
""";

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/message-server/rcs/send"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var payload = new
{
    agentId = "agent_abc",
    destination = "+391234567890",
    messageId = "ext-unique-id-002",
    body = new
    {
        type = "TEXT",
        text = "Your order #12345 is ready for pickup!"
    }
};

var content = new StringContent(
    JsonSerializer.Serialize(payload),
    Encoding.UTF8,
    "application/json"
);

var response = await client.PostAsync(
    "https://lora-api.agiletelecom.com/api/message-server/rcs/send",
    content
);
Console.WriteLine(await response.Content.ReadAsStringAsync());

payload := `{
  "agentId": "agent_abc",
  "destination": "+391234567890",
  "messageId": "ext-unique-id-002",
  "body": {
    "type": "TEXT",
    "text": "Your order #12345 is ready for pickup!"
  }
}`

client := &http.Client{}
req, _ := http.NewRequest("POST",
    "https://lora-api.agiletelecom.com/api/message-server/rcs/send",
    strings.NewReader(payload))

req.Header.Add("X-Api-Key", "YOUR_API_KEY")
req.Header.Add("Content-Type", "application/json")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/message-server/rcs/send")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

payload = {
    agentId: 'agent_abc',
    destination: '+391234567890',
    messageId: 'ext-unique-id-002',
    body: {
        type: 'TEXT',
        text: 'Your order #12345 is ready for pickup!'
    }
}

request = Net::HTTP::Post.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"
request["Content-Type"] = "application/json"
request.body = JSON.generate(payload)

response = http.request(request)
puts JSON.parse(response.body)

For the full body structure including CARD, CAROUSEL, Suggestions, Media, Placeholders, and SMS Fallback, see RCS Templates.

Scheduling and simulation

scheduledDate: ISO-8601 format; timezone handling is the client's responsibility
simulation: Test mode; responses indicate platform acceptance but no actual send occurs

SMS Fallback

Requires an authorized SMS sender. Authorization can be requested free of charge in the platform.

Asynchronous events: Delivery and Read

Final outcomes don't arrive in the immediate response but via webhook to your configured endpoint. The send response only indicates acceptance.

Delivery

Message delivery notification.

{
  "channel": "RCS",
  "eventType": "DELIVERY",
  "messageId": "ext-unique-id-001",
  "destination": "+391234567890",
  "statusCode": "DELIVERED",
  "description": "Message delivered",
  "timestamp": "2025-11-12T10:30:10Z"
}

Read

Message read notification.

{
  "channel": "RCS",
  "eventType": "READ",
  "messageId": "ext-unique-id-001",
  "destination": "+391234567890",
  "timestamp": "2025-11-12T10:32:45Z"
}

Webhook retries

The platform performs up to five retries spaced several minutes apart. If you don't respond correctly, retries stop after the fifth attempt.

Inbound messages and Media

User responses and multimedia content arrive at your configured Inbound endpoint.

Inbound text

Contains text and any emojis inserted by the user.

{
  "channel": "RCS",
  "messageType": "TEXT",
  "source": "+391234567890",
  "destination": "agent_abc",
  "receivedDate": "2025-11-12T10:35:20Z",
  "text": "Yes, I'm interested"
}

Inbound with media

Contains a key (mediaKey) to retrieve an image or file sent by the user.

{
  "channel": "RCS",
  "messageType": "IMAGE",
  "source": "+391234567890",
  "destination": "agent_abc",
  "receivedDate": "2025-11-12T10:36:05Z",
  "mediaKey": "rcs-media-001"
}

Download media

Fetch the media file using the key from an inbound message. The temporary download URL expires after the specified minutes.

curl -X GET "https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15" \
  -H "X-Api-Key: YOUR_API_KEY"

import requests

headers = {"X-Api-Key": "YOUR_API_KEY"}
params = {"expireMinutes": 15}

response = requests.get(
    "https://lora-api.agiletelecom.com/api/files/rcs-media-001",
    headers=headers,
    params=params
)
print(response.json())

const fetch = require('node-fetch');

const headers = { 'X-Api-Key': 'YOUR_API_KEY' };

fetch('https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15', {
    method: 'GET',
    headers
})
.then(r => r.json())
.then(data => console.log(data));

<?php
$url = "https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15";
$headers = ["X-Api-Key: YOUR_API_KEY"];

$ch = curl_init();
curl_setopt_array($ch, [
    CURLOPT_URL => $url,
    CURLOPT_HTTPHEADER => $headers,
    CURLOPT_RETURNTRANSFER => true
]);

echo json_decode(curl_exec($ch), true);
curl_close($ch);
?>

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15"))
    .header("X-Api-Key", "YOUR_API_KEY")
    .GET()
    .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-Api-Key", "YOUR_API_KEY");

var response = await client.GetAsync(
    "https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15"
);
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);

client := &http.Client{}
req, _ := http.NewRequest("GET",
    "https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15",
    nil)

req.Header.Add("X-Api-Key", "YOUR_API_KEY")

resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(body))

require 'net/http'
require 'json'

uri = URI("https://lora-api.agiletelecom.com/api/files/rcs-media-001?expireMinutes=15")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request["X-Api-Key"] = "YOUR_API_KEY"

response = http.request(request)
puts JSON.parse(response.body)

Response: A public and temporary URL for downloading the media file.

Best practices

Placeholders: Always provide required values; otherwise substitution won't occur
Media: Use public and stable URLs for the entire campaign duration; always set an appropriate height value
Suggestions: Respect the required fields for each action type
Idempotency: Always use unique messageIds
Error handling: Handle 4xx (input errors) and 5xx (temporary errors) with exponential backoff

Postman Collection

Import the official collection to quickly test all endpoints in an interactive environment.

Step 1: Import the collection

Open Postman → Import
Select the file: AgileTelecom RCS API.postman_collection.json
Confirm with Import

The collection includes requests for Agents, Template CRUD, Sending, example webhooks, and media download.

Step 2: Configure collection variables

Click the AgileTelecom RCS API collection
Open the Variables tab and fill in:

Variable	Value	Use
BASE_URL	`https://lora-api.agiletelecom.com`	Base URL for all requests
API_KEY	Your API key	Authentication
DESTINATION	`+391234567890`	Recipient number
AGENT_ID	Agent ID (from GET /rcs/agents)	Message sending
TEMPLATE_ID_TEXT	TEXT template ID	Test sending
TEMPLATE_ID_CARD	CARD template ID	Test sending
SCHEDULED_DATE	`2026-04-30T18:50:00Z`	Scheduled sends
MESSAGE_ID	`uuid-1`	Unique message ID
MEDIA_KEY	Media key	Inbound media download

Important note

If after import you find BASE_URL with a different value, replace it with https://lora-api.agiletelecom.com in the collection Variables tab. Remember the X-Api-Key: \{\{API_KEY\}\} header in requests that require it.

Step 3: Execute requests

Agents: GET \{\{BASE_URL\}\}/api/message-server/rcs/agents
Templates (CRUD):
- List: GET \{\{BASE_URL\}\}/api/message-server/rcs/templates?limit=10&page=1
- Details: GET \{\{BASE_URL\}\}/api/message-server/rcs/templates/:id
- Create: POST \{\{BASE_URL\}\}/api/message-server/rcs/templates
- Update: PUT \{\{BASE_URL\}\}/api/message-server/rcs/templates/:id
- Delete: DELETE \{\{BASE_URL\}\}/api/message-server/rcs/templates/:id
Sending:
- From template: POST \{\{BASE_URL\}\}/api/message-server/rcs/send
- Free-form: POST \{\{BASE_URL\}\}/api/message-server/rcs/send with complete body
Media: GET \{\{BASE_URL\}\}/api/files/:mediaKey?expireMinutes=180

Example template-based send:

POST {{BASE_URL}}/api/message-server/rcs/send
X-Api-Key: {{API_KEY}}
Content-Type: application/json

{
  "templateId": "{{TEMPLATE_ID_TEXT}}",
  "destination": "{{DESTINATION}}",
  "agentId": "{{AGENT_ID}}",
  "messageId": "{{MESSAGE_ID}}",
  "placeholders": {"name": "Anna"}
}

Troubleshooting

Q: I see {name} in the received message. Why?

A: The placeholder value is missing from the send request. Always provide values for all placeholders used in your template, or remove the variable from the template.

Q: The image won't load in my message.

A: Verify the image URL is publicly accessible and that you've set the height property correctly in your template.

Q: The send response says "accepted". Did the send succeed?

A: "Accepted" means the platform queued your message. Final delivery status arrives later via the DELIVERY webhook event.

Q: SMS fallback isn't sending.

A: Ensure the SMS sender is authorized in the platform. You can request authorization through your admin dashboard at no charge.

Q: How do I check if a recipient supports RCS?

A: Use the SMS fallback feature to handle RCS-unreachable contacts. Observe DELIVERY status codes to identify which contacts received the message via RCS versus SMS.

What's next?

See RCS Templates for the complete template structure and field reference
Configure webhooks to receive Delivery/Read events and Inbound responses
Test your integration with the Postman Collection

Why use RCS​

Use cases​

Core concepts​

Message types​

Suggestions (CTA)​

Media​

Placeholders​

SMS Fallback​

Authentication and security​

Quickstart​

RCS Agents​

List agents​

RCS Templates (CRUD)​

List templates​

Get template details​

Create template​

Update template​

Delete template​

Sending messages​

Send from template​

Send without template (free-form)​

Scheduling and simulation​

Asynchronous events: Delivery and Read​

Delivery​

Read​

Inbound messages and Media​

Inbound text​

Inbound with media​

Download media​

Best practices​

Postman Collection​

Step 1: Import the collection​

Step 2: Configure collection variables​

Step 3: Execute requests​

Troubleshooting​

What's next?​

Why use RCS

Use cases

Core concepts

Message types

Suggestions (CTA)

Media

Placeholders

SMS Fallback

Authentication and security

Quickstart

RCS Agents

List agents

RCS Templates (CRUD)

List templates

Get template details

Create template

Update template

Delete template

Sending messages

Send from template

Send without template (free-form)

Scheduling and simulation

Asynchronous events: Delivery and Read

Delivery

Read

Inbound messages and Media

Inbound text

Inbound with media

Download media

Best practices

Postman Collection

Step 1: Import the collection

Step 2: Configure collection variables

Step 3: Execute requests

Troubleshooting

What's next?