---
"@context": https://schema.org
"@type": TechArticle
"@id": https://www.twilio.com/docs/configurations/recording-configuration-resource#article
headline: Recording Configurations resource
description: Create, retrieve, update, and delete Twilio Voice Recording Configurations to apply reusable recording settings to calls and conferences by ID.
url: https://www.twilio.com/docs/configurations/recording-configuration-resource
inLanguage: en
dateModified: 2026-09-28T13:08:32.000Z
author:
  "@type": Organization
  name: Twilio Developer Education Team
publisher:
  "@type": Organization
  name: Twilio
---

# Recording Configurations resource

> \[!WARNING]
>
> For Customers building HIPAA-compliant workflows with [Recordings](/docs/voice/api/recording), we require customers to enforce at least HTTP Authentication. To learn more about building for HIPAA compliance, please visit the latest requirements [here](https://docs-resources.prod.twilio.com/documents/architecting-for-HIPAA.pdf).

> \[!NOTE]
>
> Call recordings aren't Payment Card Industry (PCI) compliant by default. To use Voice Recordings in a [PCI workflow](/docs/voice/pci-workflows), [enable PCI Mode in the Twilio Console](https://www.twilio.com/console/voice/settings).
>
> To transcribe voice recordings, use the \<Transcription> TwiML noun. Native and Marketplace transcriptions aren't available when PCI Mode is enabled.

The Voice Recording Configuration resource represents recording settings associated with a voice call or conference. With the Voice Recording Configuration resource, you can create, update, retrieve, and delete reusable recording settings in one place.

A recording configuration is an alternative to setting individual recording parameters in your code or TwiML (both approaches achieve the same result), but you must use one or the other. Don't mix a recording configuration ID with programmatic recording parameters in the same workflow, as doing so can produce unexpected recording output.

To use a recording configuration, pass the configuration ID as the `recordingConfigurationId` parameter in any of the following recording methods:

* [`<Record>` in TwiML](/docs/voice/twiml/record)
* [`<Dial record>` in TwiML](/docs/voice/twiml/dial#record)
* [`<Conference record>` in TwiML](/docs/voice/twiml/conference#record)
* [`<Record=true>` in an outbound call using the REST API](/docs/voice/tutorials/how-to-make-outbound-phone-calls#record-your-call)
* [`POST` to Recording resource of an in-progress Call SID](/docs/voice/api/recording)
* [`<Start><Recording>` in TwiML](/docs/voice/twiml/recording)

> \[!NOTE]
>
> The Voice Recording Configuration resource is only available in the `us1` region.

## Create a Recording Configuration

To create a Recording Configuration, send a `POST` request to the `Configurations/Recording` endpoint.

Create a Recording Configuration

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createRecordingConfiguration() {
  const recording = await client.voice.v2.recording.create({
    unique_name: "my_recording_config",
    description: "My recording configuration",
    configuration: {
      configurationType: "Recording",
      compositionPolicy: {
        channels: "dual",
        trim: "trim-silence",
        track: "both",
      },
      callRecordingStatusCallback: {
        url: "https://example.com/call-recording-status",
        method: "POST",
        events: ["in-progress", "completed"],
      },
      features: [
        {
          type: "transcriptionConfiguration",
          featureId:
            "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
          description: "Transcribe recordings created with this configuration",
        },
      ],
    },
  });

  console.log(recording.id);
}

createRecordingConfiguration();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
from twilio.rest.voice.v2 import RecordingList

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

recording = client.voice.v2.recording.create(
    voice_v2_configuration_recording_request=RecordingList.VoiceV2ConfigurationRecordingRequest(
        {
            "unique_name": "my_recording_config",
            "description": "My recording configuration",
            "configuration": RecordingList.VoiceV2ConfigurationRecordingConfiguration(
                {
                    "configurationType": "Recording",
                    "compositionPolicy": RecordingList.VoiceV2ConfigurationRecordingCompositionPolicy(
                        {
                            "channels": "dual",
                            "trim": "trim-silence",
                            "track": "both",
                        }
                    ),
                    "callRecordingStatusCallback": RecordingList.VoiceV2ConfigurationRecordingStatusCallback(
                        {
                            "url": "https://example.com/call-recording-status",
                            "method": "POST",
                            "events": ["in-progress", "completed"],
                        }
                    ),
                    "features": [
                        RecordingList.VoiceV2ConfigurationRecordingFeature(
                            {
                                "type": "transcriptionConfiguration",
                                "featureId": "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
                                "description": "Transcribe recordings created with this configuration",
                            }
                        )
                    ],
                }
            ),
        }
    )
)

print(recording.id)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Voice.V2;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var recording = await RecordingResource.CreateAsync(new CreateRecordingOptions() {
            VoiceV2ConfigurationRecordingRequest =
                new RecordingResource.VoiceV2ConfigurationRecordingRequest.Builder()
                    .WithUniqueName("my_recording_config")
                    .WithDescription("My recording configuration")
                    .WithConfiguration(
                        new RecordingResource.VoiceV2ConfigurationRecordingConfiguration.Builder()
                            .WithConfigurationType("Recording")
                            .WithCompositionPolicy(
                                new RecordingResource.VoiceV2ConfigurationRecordingCompositionPolicy
                                    .Builder()
                                    .WithChannels("dual")
                                    .WithTrim("trim-silence")
                                    .WithTrack("both")
                                    .Build())
                            .WithCallRecordingStatusCallback(
                                new RecordingResource.VoiceV2ConfigurationRecordingStatusCallback
                                    .Builder()
                                    .WithUrl("https://example.com/call-recording-status")
                                    .WithMethod("POST")
                                    .WithEvents(new List<string> { "in-progress", "completed" })
                                    .Build())
                            .WithFeatures(new List<
                                          RecordingResource.VoiceV2ConfigurationRecordingFeature> {
                                new RecordingResource.VoiceV2ConfigurationRecordingFeature.Builder()
                                    .WithType("transcriptionConfiguration")
                                    .WithFeatureId(
                                        "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
                                    .WithDescription(
                                        "Transcribe recordings created with this configuration")
                                    .Build()
                            })
                            .Build())
                    .Build()
        });

        Console.WriteLine(recording.Id);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import com.twilio.Twilio;
import com.twilio.rest.voice.v2.Recording;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

        Recording.VoiceV2ConfigurationRecordingConfiguration configuration =
            new Recording.VoiceV2ConfigurationRecordingConfiguration();
        configuration.setConfigurationType("Recording");
        configuration.setCompositionPolicy(new HashMap<String, Object>() {
            {
                put("channels", "dual");
                put("trim", "trim-silence");
                put("track", "both");
            }
        });
        configuration.setCallRecordingStatusCallback(new HashMap<String, Object>() {
            {
                put("url", "https://example.com/call-recording-status");
                put("method", "POST");
                put("events", Arrays.asList("in-progress", "completed"));
            }
        });
        configuration.setFeatures(Arrays.asList(new HashMap<String, Object>() {
            {
                put("type", "transcriptionConfiguration");
                put("featureId", "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX");
                put("description", "Transcribe recordings created with this configuration");
            }
        }

            ));

        Recording.VoiceV2ConfigurationRecordingRequest voiceV2ConfigurationRecordingRequest =
            new Recording.VoiceV2ConfigurationRecordingRequest();
        voiceV2ConfigurationRecordingRequest.setUniqueName("my_recording_config");
        voiceV2ConfigurationRecordingRequest.setDescription("My recording configuration");
        voiceV2ConfigurationRecordingRequest.setConfiguration(voiceV2ConfigurationRecordingConfiguration);

        Recording recording = Recording.creator(voiceV2ConfigurationRecordingRequest).create();

        System.out.println(recording.getId());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	voice "github.com/twilio/twilio-go/rest/voice/v2"
	"os"
)

func main() {
	// Find your Account SID at twilio.com/console
	// Provision API Keys at twilio.com/console/runtime/api-keys
	// and set the environment variables. See http://twil.io/secure
	// For local testing, you can use your Account SID and Auth token
	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
	apiKey := os.Getenv("TWILIO_API_KEY")
	apiSecret := os.Getenv("TWILIO_API_SECRET")
	client := twilio.NewRestClientWithParams(twilio.ClientParams{
		Username:   apiKey,
		Password:   apiSecret,
		AccountSid: accountSid,
	})

	params := &voice.CreateRecordingConfigurationParams{}
	params.SetVoiceV2ConfigurationRecordingRequest(voice.VoiceV2ConfigurationRecordingRequest{
		UniqueName:  "my_recording_config",
		Description: "My recording configuration",
		Configuration: voice.VoiceV2ConfigurationRecordingConfiguration{
			ConfigurationType: "Recording",
			CompositionPolicy: voice.VoiceV2ConfigurationRecordingCompositionPolicy{
				Channels: "dual",
				Trim:     "trim-silence",
				Track:    "both",
			},
			CallRecordingStatusCallback: voice.VoiceV2ConfigurationRecordingStatusCallback{
				Url:    "https://example.com/call-recording-status",
				Method: "POST",
				Events: []string{
					"in-progress",
					"completed",
				},
			},
			Features: []voice.VoiceV2ConfigurationRecordingFeature{
				voice.VoiceV2ConfigurationRecordingFeature{
					Type:        "transcriptionConfiguration",
					FeatureId:   "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
					Description: "Transcribe recordings created with this configuration",
				},
			},
		},
	})

	resp, err := client.VoiceV2.CreateRecordingConfiguration(params)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		fmt.Println(resp.Id)
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;
use Twilio\Rest\Voice\V2\RecordingModels;

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
$apiKey = $_ENV["TWILIO_API_KEY"];
$apiSecret = $_ENV["TWILIO_API_SECRET"];
$sid = $_ENV["TWILIO_ACCOUNT_SID"];
$twilio = new Client($apiKey, $apiSecret, $sid);

$recording = $twilio->voice->v2->recording->create(
    RecordingModels::createVoiceV2ConfigurationRecordingRequest([
        "uniqueName" => "my_recording_config",
        "description" => "My recording configuration",
        "configuration" => RecordingModels::createVoiceV2ConfigurationRecordingConfiguration(
            [
                "configurationType" => "Recording",
                "compositionPolicy" => RecordingModels::createVoiceV2ConfigurationRecordingCompositionPolicy(
                    [
                        "channels" => "dual",
                        "trim" => "trim-silence",
                        "track" => "both",
                    ],
                ),
                "callRecordingStatusCallback" => RecordingModels::createVoiceV2ConfigurationRecordingStatusCallback(
                    [
                        "url" => "https://example.com/call-recording-status",
                        "method" => "POST",
                        "events" => ["in-progress", "completed"],
                    ],
                ),
                "features" => [
                    RecordingModels::createVoiceV2ConfigurationRecordingFeature(
                        [
                            "type" => "transcriptionConfiguration",
                            "featureId" =>
                                "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
                            "description" =>
                                "Transcribe recordings created with this configuration",
                        ],
                    ),
                ],
            ],
        ),
    ]),
);

print $recording->id;
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

recording = @client
            .voice
            .v2
            .recording
            .create(
              voice_v2_configuration_recording_request: {
                'unique_name' => 'my_recording_config',
                'description' => 'My recording configuration',
                'configuration' => {
                  'configurationType' => 'Recording',
                  'compositionPolicy' => {
                    'channels' => 'dual',
                    'trim' => 'trim-silence',
                    'track' => 'both'
                  },
                  'callRecordingStatusCallback' => {
                    'url' => 'https://example.com/call-recording-status',
                    'method' => 'POST',
                    'events' => [
                      'in-progress',
                      'completed'
                    ]
                  },
                  'features' => [
                    {
                      'type' => 'transcriptionConfiguration',
                      'featureId' => 'voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX',
                      'description' => 'Transcribe recordings created with this configuration'
                    }
                  ]
                }
              }
            )

puts recording.id
```

```bash
# This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
  # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
```

```bash
VOICE_V2_CONFIGURATION_RECORDING_REQUEST_OBJ=$(cat << EOF
{
  "unique_name": "my_recording_config",
  "description": "My recording configuration",
  "configuration": {
    "configurationType": "Recording",
    "compositionPolicy": {
      "channels": "dual",
      "trim": "trim-silence",
      "track": "both"
    },
    "callRecordingStatusCallback": {
      "url": "https://example.com/call-recording-status",
      "method": "POST",
      "events": [
        "in-progress",
        "completed"
      ]
    },
    "features": [
      {
        "type": "transcriptionConfiguration",
        "featureId": "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
        "description": "Transcribe recordings created with this configuration"
      }
    ]
  }
}
EOF
)
curl -X POST "https://voice.twilio.com/v2/Configurations/Recording" \
--json "$VOICE_V2_CONFIGURATION_RECORDING_REQUEST_OBJ" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

```json
{
    "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "configuration": {
        "configurationType": "Recording",
        "compositionPolicy": {
            "channels": "dual",
            "trim": "trim-silence",
            "track": "both"
        },
        "callRecordingStatusCallback": {
            "url": "https://example.com/call-recording-status",
            "method": "POST",
            "events": ["in-progress", "completed"]
        },
        "features": [
            {
                "type": "transcriptionConfiguration",
                "featureId": "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
                "description": "Transcribe recordings created with this configuration"
            }
        ]
    },
    "description": "My recording configuration",
    "unique_name": "my_recording_config",
    "date_created": "2026-04-15T11:00:00Z",
    "date_updated": "2026-04-15T11:00:00Z",
    "id": "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
}
```

### Request body parameters

| Parameter       | Type   | Required | Description                                                                                        |
| :-------------- | :----- | :------- | :------------------------------------------------------------------------------------------------- |
| `unique_name`   | string | No       | A unique, human-readable name for this configuration. Cannot contain spaces.                       |
| `description`   | string | No       | A description of this configuration.                                                               |
| `configuration` | object | Yes      | The configuration object. See [Configuration object properties](#configuration-object-properties). |

### Configuration object properties

| Property                            | Type   | Required | Description                                                                                                                                                |
| :---------------------------------- | :----- | :------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `configurationType`                 | string | Yes      | Must be `Recording`.                                                                                                                                       |
| `compositionPolicy`                 | object | No       | The composition configuration for recordings. See [compositionPolicy properties](#compositionpolicy-properties).                                           |
| `callRecordingStatusCallback`       | object | No       | Callback configuration for individual (call) recording status. See [callRecordingStatusCallback properties](#callrecordingstatuscallback-properties).      |
| `conferenceRecordingStatusCallback` | object | No       | Callback configuration for conference recording status. See [conferenceRecordingStatusCallback properties](#conferencerecordingstatuscallback-properties). |
| `features`                          | array  | No       | The features to apply to this recording. Up to three features can be added to the `features` object. See [features properties](#features-properties).      |

### compositionPolicy properties

| Property   | Type   | Description                                                                                                                                                                                                                                                                                    |
| :--------- | :----- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `channels` | string | The number of channels used in the recording. Can be: `mono` or `dual` and the default is `dual`. `mono` records all parties of the call into one channel. `dual` records each party of a 2-party call into separate channels.                                                                 |
| `trim`     | string | Whether to trim any leading and trailing silence in the recording. Can be: `trim-silence` or `do-not-trim` and the default is `do-not-trim`. `trim-silence` trims the silence from the beginning and end of the recording and `do-not-trim` does not.                                          |
| `track`    | string | The audio track to record for the call. Can be: `inbound`, `outbound` or `both`. The default is `both`. `inbound` records the audio that is received by Twilio. `outbound` records the audio that is generated from Twilio. `both` records the audio that is received and generated by Twilio. |

### callRecordingStatusCallback properties

| Property | Type   | Description                                                                                                                                                                                                                                                 |
| :------- | :----- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url`    | string | The URL we should call using the method on each recording event specified in the events property of the `callRecordingStatusCallback` object.                                                                                                               |
| `method` | string | The HTTP method we should use to call `call_recording_status_callback`. Can be: `GET` or `POST` and the default is `POST`.                                                                                                                                  |
| `events` | array  | The recording status events on which we should call the `call_recording_status_callback` URL. Can be: `in-progress`, `completed`, `failed`, and `absent` and the default is `completed`. Separate multiple values with a space, ex: 'in-progress completed' |

### conferenceRecordingStatusCallback properties

| Property | Type   | Description                                                                                                                                                                                                                                                                  |
| :------- | :----- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `url`    | string | The URL we should call using the method on each conference recording event specified in the events property of the `conferenceRecordingStatusCallback` object.                                                                                                               |
| `method` | string | The HTTP method we should use to call `conference_recording_status_callback`. Can be: `GET` or `POST` and the default is `POST`.                                                                                                                                             |
| `events` | array  | The conference recording status events on which we should call the `conference_recording_status_callback` URL. Can be: `in-progress`, `completed`, `failed`, and `absent` and the default is `completed`. Separate multiple values with a space, ex: 'in-progress completed' |

### features properties

| Property      | Type   | Required | Description                                                                                   |
| :------------ | :----- | :------- | :-------------------------------------------------------------------------------------------- |
| `type`        | string | Yes      | The type of feature to apply to the recording. Possible values: `transcriptionConfiguration`. |
| `featureId`   | string | Yes      | The ID of the feature.                                                                        |
| `description` | string | No       | The description of the feature.                                                               |

> \[!NOTE]
>
> The Batch Transcription Configuration accepts only dual-channel recordings. Twilio stores all call recordings (where `track` = `both`) and conference recordings (with the [Dual-channel Recording for Conference Console setting enabled](https://1console.twilio.com/)) in a dual-channel format by default. These recordings can be transcribed regardless of whether `channels` is set to `mono` or `dual`.

## Examples of using a Recording Configuration

### Record an outbound call using a Voice Recording Configuration

Record an outbound call using a Voice Recording Configuration

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createCall() {
  const call = await client.calls.create({
    from: "+15017122661",
    record: true,
    recordingConfigurationId:
      "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
    to: "+15558675310",
    url: "http://demo.twilio.com/docs/voice.xml",
  });

  console.log(call.sid);
}

createCall();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

call = client.calls.create(
    url="http://demo.twilio.com/docs/voice.xml",
    to="+15558675310",
    from_="+15017122661",
    record=True,
    recording_configuration_id="voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
)

print(call.sid)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Api.V2010.Account;
using System.Threading.Tasks;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var call = await CallResource.CreateAsync(
            url: new Uri("http://demo.twilio.com/docs/voice.xml"),
            to: new Twilio.Types.PhoneNumber("+15558675310"),
            from: new Twilio.Types.PhoneNumber("+15017122661"),
            record: true,
            recordingConfigurationId: "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX");

        Console.WriteLine(call.Sid);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.net.URI;
import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
        Call call = Call.creator(new com.twilio.type.PhoneNumber("+15558675310"),
                            new com.twilio.type.PhoneNumber("+15017122661"),
                            URI.create("http://demo.twilio.com/docs/voice.xml"))
                        .setRecord(true)
                        .setRecordingConfigurationId("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
                        .create();

        System.out.println(call.getSid());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	api "github.com/twilio/twilio-go/rest/api/v2010"
	"os"
)

func main() {
	// Find your Account SID at twilio.com/console
	// Provision API Keys at twilio.com/console/runtime/api-keys
	// and set the environment variables. See http://twil.io/secure
	// For local testing, you can use your Account SID and Auth token
	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
	apiKey := os.Getenv("TWILIO_API_KEY")
	apiSecret := os.Getenv("TWILIO_API_SECRET")
	client := twilio.NewRestClientWithParams(twilio.ClientParams{
		Username:   apiKey,
		Password:   apiSecret,
		AccountSid: accountSid,
	})

	params := &api.CreateCallParams{}
	params.SetUrl("http://demo.twilio.com/docs/voice.xml")
	params.SetTo("+15558675310")
	params.SetFrom("+15017122661")
	params.SetRecord(true)
	params.SetRecordingConfigurationId("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")

	resp, err := client.Api.CreateCall(params)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		if resp.Sid != nil {
			fmt.Println(*resp.Sid)
		} else {
			fmt.Println(resp.Sid)
		}
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
$apiKey = $_ENV["TWILIO_API_KEY"];
$apiSecret = $_ENV["TWILIO_API_SECRET"];
$sid = $_ENV["TWILIO_ACCOUNT_SID"];
$twilio = new Client($apiKey, $apiSecret, $sid);

$call = $twilio->calls->create(
    "+15558675310", // To
    "+15017122661", // From
    [
        "url" => "http://demo.twilio.com/docs/voice.xml",
        "record" => true,
        "recordingConfigurationId" =>
            "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
    ],
);

print $call->sid;
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

call = @client
       .api
       .v2010
       .calls
       .create(
         url: 'http://demo.twilio.com/docs/voice.xml',
         to: '+15558675310',
         from: '+15017122661',
         record: true,
         recording_configuration_id: 'voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX'
       )

puts call.sid
```

```bash
# Install the twilio-cli from https://twil.io/cli

twilio api:core:calls:create \
   --url http://demo.twilio.com/docs/voice.xml \
   --to +15558675310 \
   --from +15017122661 \
   --record \
   --recording-configuration-id voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX
```

```bash
curl -X POST "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID/Calls.json" \
--data-urlencode "Url=http://demo.twilio.com/docs/voice.xml" \
--data-urlencode "To=+15558675310" \
--data-urlencode "From=+15017122661" \
--data-urlencode "Record=true" \
--data-urlencode "RecordingConfigurationId=voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

### Record a conference participant using a Voice Recording Configuration

Record a conference participant using a Voice Recording Configuration

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function createParticipant() {
  const participant = await client
    .conferences("CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
    .participants.create({
      from: "+15017122661",
      label: "customer",
      record: true,
      recordingConfigurationId:
        "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
      statusCallback: "https://myapp.com/events",
      statusCallbackEvent: ["ringing"],
      to: "+15558675310",
    });

  console.log(participant.accountSid);
}

createParticipant();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

participant = client.conferences(
    "CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
).participants.create(
    to="+15558675310",
    from_="+15017122661",
    label="customer",
    status_callback="https://myapp.com/events",
    status_callback_event=["ringing"],
    record=True,
    recording_configuration_id="voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
)

print(participant.account_sid)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Api.V2010.Account.Conference;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var participant = await ParticipantResource.CreateAsync(
            to: new Twilio.Types.PhoneNumber("+15558675310"),
            from: new Twilio.Types.PhoneNumber("+15017122661"),
            label: "customer",
            statusCallback: new Uri("https://myapp.com/events"),
            statusCallbackEvent: new List<string> { "ringing" },
            record: true,
            recordingConfigurationId: "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
            pathConferenceSid: "CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

        Console.WriteLine(participant.AccountSid);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.net.URI;
import java.util.Arrays;
import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.conference.Participant;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
        Participant participant =
            Participant
                .creator("CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                    new com.twilio.type.PhoneNumber("+15017122661"),
                    new com.twilio.type.PhoneNumber("+15558675310"))
                .setLabel("customer")
                .setStatusCallback(URI.create("https://myapp.com/events"))
                .setStatusCallbackEvent(Arrays.asList("ringing"))
                .setRecord(true)
                .setRecordingConfigurationId("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
                .create();

        System.out.println(participant.getAccountSid());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	api "github.com/twilio/twilio-go/rest/api/v2010"
	"os"
)

func main() {
	// Find your Account SID at twilio.com/console
	// Provision API Keys at twilio.com/console/runtime/api-keys
	// and set the environment variables. See http://twil.io/secure
	// For local testing, you can use your Account SID and Auth token
	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
	apiKey := os.Getenv("TWILIO_API_KEY")
	apiSecret := os.Getenv("TWILIO_API_SECRET")
	client := twilio.NewRestClientWithParams(twilio.ClientParams{
		Username:   apiKey,
		Password:   apiSecret,
		AccountSid: accountSid,
	})

	params := &api.CreateParticipantParams{}
	params.SetTo("+15558675310")
	params.SetFrom("+15017122661")
	params.SetLabel("customer")
	params.SetStatusCallback("https://myapp.com/events")
	params.SetStatusCallbackEvent([]string{
		"ringing",
	})
	params.SetRecord(true)
	params.SetRecordingConfigurationId("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")

	resp, err := client.Api.CreateParticipant("CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
		params)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		if resp.AccountSid != nil {
			fmt.Println(*resp.AccountSid)
		} else {
			fmt.Println(resp.AccountSid)
		}
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
$apiKey = $_ENV["TWILIO_API_KEY"];
$apiSecret = $_ENV["TWILIO_API_SECRET"];
$sid = $_ENV["TWILIO_ACCOUNT_SID"];
$twilio = new Client($apiKey, $apiSecret, $sid);

$participant = $twilio
    ->conferences("CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
    ->participants->create(
        "+15017122661", // From
        "+15558675310", // To
        [
            "label" => "customer",
            "statusCallback" => "https://myapp.com/events",
            "statusCallbackEvent" => ["ringing"],
            "record" => true,
            "recordingConfigurationId" =>
                "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
        ],
    );

print $participant->accountSid;
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

participant = @client
              .api
              .v2010
              .conferences('CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
              .participants
              .create(
                to: '+15558675310',
                from: '+15017122661',
                label: 'customer',
                status_callback: 'https://myapp.com/events',
                status_callback_event: [
                  'ringing'
                ],
                record: true,
                recording_configuration_id: 'voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX'
              )

puts participant.account_sid
```

```bash
# Install the twilio-cli from https://twil.io/cli

twilio api:core:conferences:participants:create \
   --conference-sid CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
   --to +15558675310 \
   --from +15017122661 \
   --label customer \
   --status-callback https://myapp.com/events \
   --status-callback-event ringing \
   --record \
   --recording-configuration-id voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX
```

```bash
curl -X POST "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID/Conferences/CFxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/Participants.json" \
--data-urlencode "To=+15558675310" \
--data-urlencode "From=+15017122661" \
--data-urlencode "Label=customer" \
--data-urlencode "StatusCallback=https://myapp.com/events" \
--data-urlencode "StatusCallbackEvent=ringing" \
--data-urlencode "Record=true" \
--data-urlencode "RecordingConfigurationId=voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

### Record a call with `<Start><Recording>` and a Voice Recording Configuration

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Response>
  <Start>
    <Recording recordingConfigurationId="voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX" />
  </Start>
  <Say>The recording has started.</Say>
</Response>
```

## Retrieve a Recording Configuration

To retrieve a Recording Configuration, send a `GET` request that includes the configuration ID.

Retrieve a Recording Configuration

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function fetchRecordingConfiguration() {
  const recording = await client.voice.v2
    .recording("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
    .fetch();

  console.log(recording.id);
}

fetchRecordingConfiguration();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

recording = client.voice.v2.recording(
    "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
).fetch()

print(recording.id)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Voice.V2;
using System.Threading.Tasks;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var recording = await RecordingResource.FetchAsync(
            pathIdOrUniqueName: "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX");

        Console.WriteLine(recording.Id);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import com.twilio.Twilio;
import com.twilio.rest.voice.v2.Recording;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
        Recording recording = Recording.fetcher("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX").fetch();

        System.out.println(recording.getId());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	"os"
)

func main() {
	// Find your Account SID at twilio.com/console
	// Provision API Keys at twilio.com/console/runtime/api-keys
	// and set the environment variables. See http://twil.io/secure
	// For local testing, you can use your Account SID and Auth token
	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
	apiKey := os.Getenv("TWILIO_API_KEY")
	apiSecret := os.Getenv("TWILIO_API_SECRET")
	client := twilio.NewRestClientWithParams(twilio.ClientParams{
		Username:   apiKey,
		Password:   apiSecret,
		AccountSid: accountSid,
	})

	resp, err := client.VoiceV2.FetchRecordingConfiguration("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		fmt.Println(resp.Id)
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
$apiKey = $_ENV["TWILIO_API_KEY"];
$apiSecret = $_ENV["TWILIO_API_SECRET"];
$sid = $_ENV["TWILIO_ACCOUNT_SID"];
$twilio = new Client($apiKey, $apiSecret, $sid);

$recording = $twilio->voice->v2
    ->recording("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
    ->fetch();

print $recording->id;
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

recording = @client
            .voice
            .v2
            .recording('voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX')
            .fetch

puts recording.id
```

```bash
# Install the twilio-cli from https://twil.io/cli

twilio api:voice:v2:configurations:recording:fetch \
   --id-or-unique-name voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX
```

```bash
curl -X GET "https://voice.twilio.com/v2/Configurations/Recording/voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

```json
{
    "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "configuration": {
        "configurationType": "Recording",
        "compositionPolicy": {
            "channels": "dual",
            "trim": "trim-silence"
        },
        "callRecordingStatusCallback": {
            "url": "https://example.com/call-recording-status",
            "method": "POST",
            "events": ["in-progress", "completed"]
        },
        "features": [
            {
                "type": "transcriptionConfiguration",
                "featureId": "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
                "description": "Transcribe recordings created with this configuration"
            }
        ]
    },
    "description": "My recording configuration",
    "unique_name": "my_recording_config",
    "date_created": "2026-04-15T11:00:00Z",
    "date_updated": "2026-04-15T11:00:00Z",
    "id": "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
}
```

## List Recording Configurations

To list the Recording Configurations on your account, send a `GET` request to the `Configurations/Recording` endpoint.

```bash
curl -X GET "https://voice.twilio.com/v2/Configurations/Recording?pageSize=10" \
  -u "$TWILIO_API_KEY:$TWILIO_API_SECRET"
```

```json
{
  "content": [
      {
          "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
          "configuration": {
              "configurationType": "Recording",
              "compositionPolicy": {
                  "channels": "dual",
                  "trim": "trim-silence",
                  "track": "both"
              },
              "callRecordingStatusCallback": {
                  "url": "https://example.com/call-recording-status",
                  "method": "POST",
                  "events": ["in-progress", "completed"]
              },
              "features": [
                  {
                      "type": "transcriptionConfiguration",
                      "featureId": "voice_transcriptionconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
                      "description": "Transcribe recordings created with this configuration"
                  }
              ]
          },
          "description": "My recording configuration",
          "unique_name": "my_recording_config",
          "date_created": "2026-04-15T11:00:00Z",
          "date_updated": "2026-04-15T11:00:00Z",
          "id": "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
      }
    ],
    "meta": {
        "direct_token": true,
        "list_key": "content",
        "next_token": "",
        "page_size": 10,
        "previous_token": ""
    }
}
```

> \[!NOTE]
>
> `pageSize` and `pageToken` are optional query parameters.

## Update a Recording Configuration

To update a Recording Configuration, send a `PUT` request with the new values.

Update a Recording Configuration

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function updateRecordingConfiguration() {
  const recording = await client.voice.v2
    .recording("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
    .update({
      unique_name: "my_updated_recording_config",
      description: "Updated recording configuration",
      configuration: {
        configurationType: "Recording",
        compositionPolicy: {
          channels: "mono",
          trim: "do-not-trim",
        },
        callRecordingStatusCallback: {
          url: "https://example.com/updated-callback",
          method: "POST",
          events: ["completed"],
        },
      },
    });

  console.log(recording.id);
}

updateRecordingConfiguration();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client
from twilio.rest.voice.v2 import RecordingList

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

recording_configuration = client.voice.v2.recording(
    "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
).update(
    voice_v2_configuration_recording_request=RecordingList.VoiceV2ConfigurationRecordingRequest(
        {
            "unique_name": "my_updated_recording_config",
            "description": "Updated recording configuration",
            "configuration": RecordingList.VoiceV2ConfigurationRecordingConfiguration(
                {
                    "configurationType": "Recording",
                    "compositionPolicy": RecordingList.VoiceV2ConfigurationRecordingCompositionPolicy(
                        {"channels": "mono", "trim": "do-not-trim"}
                    ),
                    "callRecordingStatusCallback": RecordingList.VoiceV2ConfigurationRecordingStatusCallback(
                        {
                            "url": "https://example.com/updated-callback",
                            "method": "POST",
                            "events": ["completed"],
                        }
                    ),
                }
            ),
        }
    )
)

print(recording_configuration.id)
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Voice.V2;
using System.Threading.Tasks;
using System.Collections.Generic;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        var recording = await RecordingResource.UpdateAsync(new UpdateRecordingOptions(
            "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX") {
            VoiceV2ConfigurationRecordingRequest =
                new RecordingResource.VoiceV2ConfigurationRecordingRequest.Builder()
                    .WithUniqueName("my_updated_recording_config")
                    .WithDescription("Updated recording configuration")
                    .WithConfiguration(
                        new RecordingResource.VoiceV2ConfigurationRecordingConfiguration.Builder()
                            .WithConfigurationType("Recording")
                            .WithCompositionPolicy(
                                new RecordingResource.VoiceV2ConfigurationRecordingCompositionPolicy
                                    .Builder()
                                    .WithChannels("mono")
                                    .WithTrim("do-not-trim")
                                    .Build())
                            .WithCallRecordingStatusCallback(
                                new RecordingResource.VoiceV2ConfigurationRecordingStatusCallback
                                    .Builder()
                                    .WithUrl("https://example.com/updated-callback")
                                    .WithMethod("POST")
                                    .WithEvents(new List<string> { "completed" })
                                    .Build())
                            .Build())
                    .Build()
        });

        Console.WriteLine(recording.Id);
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import java.util.Arrays;
import java.util.HashMap;
import com.twilio.Twilio;
import com.twilio.rest.voice.v2.Recording;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);

        Recording.VoiceV2ConfigurationRecordingConfiguration configuration =
            new Recording.VoiceV2ConfigurationRecordingConfiguration();
        configuration.setConfigurationType("Recording");
        configuration.setCompositionPolicy(new HashMap<String, Object>() {
            {
                put("channels", "mono");
                put("trim", "do-not-trim");
            }
        });
        configuration.setCallRecordingStatusCallback(new HashMap<String, Object>() {
            {
                put("url", "https://example.com/updated-callback");
                put("method", "POST");
                put("events", Arrays.asList("completed"));
            }
        });

        Recording.VoiceV2ConfigurationRecordingRequest voiceV2ConfigurationRecordingRequest =
            new Recording.VoiceV2ConfigurationRecordingRequest();
        voiceV2ConfigurationRecordingRequest.setUniqueName("my_updated_recording_config");
        voiceV2ConfigurationRecordingRequest.setDescription("Updated recording configuration");
        voiceV2ConfigurationRecordingRequest.setConfiguration(voiceV2ConfigurationRecordingConfiguration);

        Recording recording = Recording
                                  .updater("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
                                      voiceV2ConfigurationRecordingRequest)
                                  .update();

        System.out.println(recording.getId());
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	voice "github.com/twilio/twilio-go/rest/voice/v2"
	"os"
)

func main() {
	// Find your Account SID at twilio.com/console
	// Provision API Keys at twilio.com/console/runtime/api-keys
	// and set the environment variables. See http://twil.io/secure
	// For local testing, you can use your Account SID and Auth token
	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
	apiKey := os.Getenv("TWILIO_API_KEY")
	apiSecret := os.Getenv("TWILIO_API_SECRET")
	client := twilio.NewRestClientWithParams(twilio.ClientParams{
		Username:   apiKey,
		Password:   apiSecret,
		AccountSid: accountSid,
	})

	params := &voice.UpdateRecordingConfigurationParams{}
	params.SetVoiceV2ConfigurationRecordingRequest(voice.VoiceV2ConfigurationRecordingRequest{
		UniqueName:  "my_updated_recording_config",
		Description: "Updated recording configuration",
		Configuration: voice.VoiceV2ConfigurationRecordingConfiguration{
			ConfigurationType: "Recording",
			CompositionPolicy: voice.VoiceV2ConfigurationRecordingCompositionPolicy{
				Channels: "mono",
				Trim:     "do-not-trim",
			},
			CallRecordingStatusCallback: voice.VoiceV2ConfigurationRecordingStatusCallback{
				Url:    "https://example.com/updated-callback",
				Method: "POST",
				Events: []string{
					"completed",
				},
			},
		},
	})

	resp, err := client.VoiceV2.UpdateRecordingConfiguration("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX",
		params)
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	} else {
		fmt.Println(resp.Id)
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;
use Twilio\Rest\Voice\V2\RecordingModels;

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
$apiKey = $_ENV["TWILIO_API_KEY"];
$apiSecret = $_ENV["TWILIO_API_SECRET"];
$sid = $_ENV["TWILIO_ACCOUNT_SID"];
$twilio = new Client($apiKey, $apiSecret, $sid);

$recording_configuration = $twilio->voice->v2
    ->recording("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
    ->update(
        RecordingModels::createVoiceV2ConfigurationRecordingRequest([
            "uniqueName" => "my_updated_recording_config",
            "description" => "Updated recording configuration",
            "configuration" => RecordingModels::createVoiceV2ConfigurationRecordingConfiguration(
                [
                    "configurationType" => "Recording",
                    "compositionPolicy" => RecordingModels::createVoiceV2ConfigurationRecordingCompositionPolicy(
                        [
                            "channels" => "mono",
                            "trim" => "do-not-trim",
                        ],
                    ),
                    "callRecordingStatusCallback" => RecordingModels::createVoiceV2ConfigurationRecordingStatusCallback(
                        [
                            "url" => "https://example.com/updated-callback",
                            "method" => "POST",
                            "events" => ["completed"],
                        ],
                    ),
                ],
            ),
        ]),
    );

print $recording_configuration->id;
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

recording = @client
            .voice
            .v2
            .recording('voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX')
            .update(
              voice_v2_configuration_recording_request: {
                'unique_name' => 'my_updated_recording_config',
                'description' => 'Updated recording configuration',
                'configuration' => {
                  'configurationType' => 'Recording',
                  'compositionPolicy' => {
                    'channels' => 'mono',
                    'trim' => 'do-not-trim'
                  },
                  'callRecordingStatusCallback' => {
                    'url' => 'https://example.com/updated-callback',
                    'method' => 'POST',
                    'events' => [
                      'completed'
                    ]
                  }
                }
              }
            )

puts recording.id
```

```bash
# This endpoint is not currently supported by the Twilio CLI. You can open an issue to request it on https://github.com/twilio/twilio-cli/issues
  # For an alternative low-code solution, check out https://www.twilio.com/docs/openapi/using-twilio-postman-collections
```

```bash
VOICE_V2_CONFIGURATION_RECORDING_REQUEST_OBJ=$(cat << EOF
{
  "unique_name": "my_updated_recording_config",
  "description": "Updated recording configuration",
  "configuration": {
    "configurationType": "Recording",
    "compositionPolicy": {
      "channels": "mono",
      "trim": "do-not-trim"
    },
    "callRecordingStatusCallback": {
      "url": "https://example.com/updated-callback",
      "method": "POST",
      "events": [
        "completed"
      ]
    }
  }
}
EOF
)
curl -X PUT "https://voice.twilio.com/v2/Configurations/Recording/voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX" \
--json "$VOICE_V2_CONFIGURATION_RECORDING_REQUEST_OBJ" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

```json
{
    "account_sid": "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "configuration": {
        "configurationType": "Recording",
        "compositionPolicy": {
            "channels": "mono",
            "trim": "do-not-trim"
        },
        "callRecordingStatusCallback": {
            "url": "https://example.com/updated-callback",
            "method": "POST",
            "events": ["completed"]
        }
    },
    "description": "Updated recording configuration",
    "unique_name": "my_updated_recording_config",
    "date_created": "2026-04-15T11:00:00Z",
    "date_updated": "2026-04-15T12:00:00Z",
    "id": "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
}
```

> \[!NOTE]
>
> If you omit a parameter or set its value to `null` in the update request, Twilio either sets the value to `null` or returns an error, depending on whether the field is required.

## Delete a Recording Configuration

To delete a Recording Configuration, send a `DELETE` request that includes the configuration ID.

Delete a Recording Configuration

```js
// Download the helper library from https://www.twilio.com/docs/node/install
const twilio = require("twilio"); // Or, for ESM: import twilio from "twilio";

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const apiKey = process.env.TWILIO_API_KEY;
const apiSecret = process.env.TWILIO_API_SECRET;
const client = twilio(apiKey, apiSecret, { accountSid: accountSid });

async function deleteRecordingConfiguration() {
  await client.voice.v2
    .recording("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
    .remove();
}

deleteRecordingConfiguration();
```

```python
# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = os.environ["TWILIO_API_KEY"]
api_secret = os.environ["TWILIO_API_SECRET"]
account_sid = os.environ["TWILIO_ACCOUNT_SID"]
client = Client(api_key, api_secret, account_sid)

client.voice.v2.recording(
    "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX"
).delete()
```

```csharp
// Install the C# / .NET helper library from twilio.com/docs/csharp/install

using System;
using Twilio;
using Twilio.Rest.Voice.V2;
using System.Threading.Tasks;

class Program {
    public static async Task Main(string[] args) {
        // Find your Account SID at twilio.com/console
        // Provision API Keys at twilio.com/console/runtime/api-keys
        // and set the environment variables. See http://twil.io/secure
        // For local testing, you can use your Account SID and Auth token
        string apiKey = Environment.GetEnvironmentVariable("TWILIO_API_KEY");
        string apiSecret = Environment.GetEnvironmentVariable("TWILIO_API_SECRET");
        string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");

        TwilioClient.Init(apiKey, apiSecret, accountSid);

        await RecordingResource.DeleteAsync(
            pathIdOrUniqueName: "voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX");
    }
}
```

```java
// Install the Java helper library from twilio.com/docs/java/install

import com.twilio.Twilio;
import com.twilio.rest.voice.v2.Recording;

public class Example {
    // Find your Account SID at twilio.com/console
    // Provision API Keys at twilio.com/console/runtime/api-keys
    // and set the environment variables. See http://twil.io/secure
    // For local testing, you can use your Account SID and Auth token
    public static final String API_KEY = System.getenv("TWILIO_API_KEY");
    public static final String API_SECRET = System.getenv("TWILIO_API_SECRET");
    public static final String ACCOUNT_SID = System.getenv("TWILIO_ACCOUNT_SID");

    public static void main(String[] args) {
        Twilio.init(API_KEY, API_SECRET, ACCOUNT_SID);
        Recording.deleter("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX").delete();
    }
}
```

```go
// Download the helper library from https://www.twilio.com/docs/go/install
package main

import (
	"fmt"
	"github.com/twilio/twilio-go"
	"os"
)

func main() {
	// Find your Account SID at twilio.com/console
	// Provision API Keys at twilio.com/console/runtime/api-keys
	// and set the environment variables. See http://twil.io/secure
	// For local testing, you can use your Account SID and Auth token
	accountSid := os.Getenv("TWILIO_ACCOUNT_SID")
	apiKey := os.Getenv("TWILIO_API_KEY")
	apiSecret := os.Getenv("TWILIO_API_SECRET")
	client := twilio.NewRestClientWithParams(twilio.ClientParams{
		Username:   apiKey,
		Password:   apiSecret,
		AccountSid: accountSid,
	})

	err := client.VoiceV2.DeleteRecordingConfiguration("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
	if err != nil {
		fmt.Println(err.Error())
		os.Exit(1)
	}
}
```

```php
<?php

// Update the path below to your autoload.php,
// see https://getcomposer.org/doc/01-basic-usage.md
require_once "/path/to/vendor/autoload.php";

use Twilio\Rest\Client;

// Find your Account SID at twilio.com/console
// Provision API Keys at twilio.com/console/runtime/api-keys
// and set the environment variables. See http://twil.io/secure
// For local testing, you can use your Account SID and Auth token
$apiKey = $_ENV["TWILIO_API_KEY"];
$apiSecret = $_ENV["TWILIO_API_SECRET"];
$sid = $_ENV["TWILIO_ACCOUNT_SID"];
$twilio = new Client($apiKey, $apiSecret, $sid);

$twilio->voice->v2
    ->recording("voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX")
    ->delete();
```

```ruby
# Download the helper library from https://www.twilio.com/docs/ruby/install
require 'twilio-ruby'

# Find your Account SID at twilio.com/console
# Provision API Keys at twilio.com/console/runtime/api-keys
# and set the environment variables. See http://twil.io/secure
# For local testing, you can use your Account SID and Auth token
api_key = ENV['TWILIO_API_KEY']
api_secret = ENV['TWILIO_API_SECRET']
account_sid = ENV['TWILIO_ACCOUNT_SID']
@client = Twilio::REST::Client.new(api_key, api_secret, account_sid)

@client
  .voice
  .v2
  .recording('voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX')
  .delete
```

```bash
# Install the twilio-cli from https://twil.io/cli

twilio api:voice:v2:configurations:recording:remove \
   --id-or-unique-name voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX
```

```bash
curl -X DELETE "https://voice.twilio.com/v2/Configurations/Recording/voice_recordingconfiguration_XXXXXXXXXXXXXXXXXXXXXXXXXX" \
-u $TWILIO_API_KEY:$TWILIO_API_SECRET
```

A successful response returns HTTP `204 No Content` with no body.