---
title: Create Voice Content
description: The POST {{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents operation can be used to create a new customized message content resource associated with the template specified in the request URL.
component: pingone-api
page_id: pingone-api:platform:notifications/notifications-templates/create-voice-content
canonical_url: https://developer.pingidentity.com/pingone-api/platform/notifications/notifications-templates/create-voice-content.html
section_ids:
  prerequisites: Prerequisites
  headers: Headers
  body: Body
  example-request: Example Request
  example-response: Example Response
---

# Create Voice Content

##

```none
POST {{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents
```

The `POST {{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents` operation can be used to create a new customized message content resource associated with the template specified in the request URL.

The message can contain up to 1Kb characters.

In addition, the variables restrictions should apply to message notification content.

### Prerequisites

* Refer to [Notifications](../../notifications.html) for important overview information.

* Use [Read All Templates](read-all-templates.html) to retrieve a list of all notifications templates associated with the environment and select the specific `templateName` for the endpoint. For more information, refer to [Notifications Templates](../notifications-templates.html).

> **Collapse: Request Model**
>
> | Property         | Type   | Required? |
> | ---------------- | ------ | --------- |
> | `content`        | String | Required  |
> | `deliveryMethod` | String | Required  |
> | `locale`         | String | Required  |
> | `variant`        | String | Optional  |
> | `voice`          | String | Required  |
>
> Refer to the [Notifications templates property data models](../notifications-templates.html#notifications-templates-properties) for full property descriptions.

### Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

### Body

raw ( application/json )

```json
{
    "locale":"en",
    "variant": "variant_C",
    "content":" Your OTP is ${OTP}",
    "deliveryMethod": "Voice",
    "voice": "Woman"
}
```

##

### Example Request

* cURL

* C#

* Go

* HTTP

* Java

* jQuery

* NodeJS

* Python

* PHP

* Ruby

* Swift

```shell
curl --location --globoff '{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
    "locale":"en",
    "variant": "variant_C",
    "content":" Your OTP is ${OTP}",
    "deliveryMethod": "Voice",
    "voice": "Woman"
}'
```

```csharp
var options = new RestClientOptions("{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents")
{
  MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("", Method.Post);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer {{accessToken}}");
var body = @"{" + "\n" +
@"    ""locale"":""en""," + "\n" +
@"    ""variant"": ""variant_C""," + "\n" +
@"    ""content"":"" Your OTP is ${OTP}""," + "\n" +
@"    ""deliveryMethod"": ""Voice""," + "\n" +
@"    ""voice"": ""Woman""" + "\n" +
@"}";
request.AddStringBody(body, DataFormat.Json);
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);
```

```golang
package main

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

func main() {

  url := "{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents"
  method := "POST"

  payload := strings.NewReader(`{
    "locale":"en",
    "variant": "variant_C",
    "content":" Your OTP is ${OTP}",
    "deliveryMethod": "Voice",
    "voice": "Woman"
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("Authorization", "Bearer {{accessToken}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
```

```http
POST /v1/environments/{{envID}}/templates/{{templateName}}/contents HTTP/1.1
Host: {{apiPath}}
Content-Type: application/json
Authorization: Bearer {{accessToken}}

{
    "locale":"en",
    "variant": "variant_C",
    "content":" Your OTP is ${OTP}",
    "deliveryMethod": "Voice",
    "voice": "Woman"
}
```

```java
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n    \"locale\":\"en\",\n    \"variant\": \"variant_C\",\n    \"content\":\" Your OTP is ${OTP}\",\n    \"deliveryMethod\": \"Voice\",\n    \"voice\": \"Woman\"\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents")
  .method("POST", body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer {{accessToken}}")
  .build();
Response response = client.newCall(request).execute();
```

```javascript
var settings = {
  "url": "{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "locale": "en",
    "variant": "variant_C",
    "content": " Your OTP is ${OTP}",
    "deliveryMethod": "Voice",
    "voice": "Woman"
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
```

```javascript
var request = require('request');
var options = {
  'method': 'POST',
  'url': '{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "locale": "en",
    "variant": "variant_C",
    "content": " Your OTP is ${OTP}",
    "deliveryMethod": "Voice",
    "voice": "Woman"
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
```

```python
import requests
import json

url = "{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents"

payload = json.dumps({
  "locale": "en",
  "variant": "variant_C",
  "content": " Your OTP is ${OTP}",
  "deliveryMethod": "Voice",
  "voice": "Woman"
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {{accessToken}}'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
```

```php
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
  'follow_redirects' => TRUE
));
$request->setHeader(array(
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {{accessToken}}'
));
$request->setBody('{\n    "locale":"en",\n    "variant": "variant_C",\n    "content":" Your OTP is ${OTP}",\n    "deliveryMethod": "Voice",\n    "voice": "Woman"\n}');
try {
  $response = $request->send();
  if ($response->getStatus() == 200) {
    echo $response->getBody();
  }
  else {
    echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
    $response->getReasonPhrase();
  }
}
catch(HTTP_Request2_Exception $e) {
  echo 'Error: ' . $e->getMessage();
}
```

```ruby
require "uri"
require "json"
require "net/http"

url = URI("{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer {{accessToken}}"
request.body = JSON.dump({
  "locale": "en",
  "variant": "variant_C",
  "content": " Your OTP is \${OTP}",
  "deliveryMethod": "Voice",
  "voice": "Woman"
})

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

```swift
let parameters = "{\n    \"locale\":\"en\",\n    \"variant\": \"variant_C\",\n    \"content\":\" Your OTP is ${OTP}\",\n    \"deliveryMethod\": \"Voice\",\n    \"voice\": \"Woman\"\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "{{apiPath}}/v1/environments/{{envID}}/templates/{{templateName}}/contents")!,timeoutInterval: Double.infinity)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("Bearer {{accessToken}}", forHTTPHeaderField: "Authorization")

request.httpMethod = "POST"
request.httpBody = postData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data else {
    print(String(describing: error))
    return
  }
  print(String(data: data, encoding: .utf8)!)
}

task.resume()
```

### Example Response

201 Created

```json
{
    "_links": {
        "self": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/templates/strong_authentication/contents/056b50cd-4b4a-444e-94b5-a0c230427ab0"
        },
        "template": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/templates/strong_authentication"
        },
        "environment": {
            "href": "https://api.pingone.com/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
        }
    },
    "id": "056b50cd-4b4a-444e-94b5-a0c230427ab0",
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    },
    "createdAt": "2021-06-07T16:26:17.040Z",
    "updatedAt": "2021-06-07T16:26:17.040Z",
    "locale": "en",
    "variant": "variant_C",
    "template": {
        "id": "strong_authentication"
    },
    "content": " Your OTP is ${OTP}",
    "voice": "Woman",
    "deliveryMethod": "Voice",
    "default": false
}
```
