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

# Create SMS 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 text message content resource associated with the template specified in the request URL.

The size restriction on the `content` value is derived from the `content` encoding. UC-2 encoding is used for messages that contain non GSM-7 characters, and in this case, a size restriction of 67 characters is enforced. However, GSM-7 encoded messages may contain up to 153 characters. SMS content associated with the `strong_authentication` template supports line breaks. When specifying a line break, you must escape the newline character in the `content` property (for example, `"content":" Your OTP is ${OTP}. \\nPlease submit. "`).

The `sender` value may contain only alphanumeric characters and spaces, and its length may be up to 11 characters.

In some countries, including the US, it is impossible to send an SMS with an alphanumeric sender ID. For those countries, the sender ID must be empty. For international alphanumeric sender support, please refer to <https://support.twilio.com/hc/en-us/articles/223133767-International-support-for-Alphanumeric-Sender-ID>.

Due to India's pre-registration laws, "PingID" is always used as the sender ID for SMS recipients in India.

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

|   |                                                                                                                                                                                         |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|   | Before you create or update a custom content, you should always do a [GET Read One Template](read-one-template.html) on the notification template to determine its supported variables. |

### 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  |
>
> 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": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS"
}
```

##

### 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": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS"
}'
```

```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"": ""${user.username} your one time password is ${OTP}.""," + "\n" +
@"    ""deliveryMethod"": ""SMS""" + "\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": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS"
}`)

  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": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS"
}
```

```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\": \"${user.username} your one time password is ${OTP}.\",\n    \"deliveryMethod\": \"SMS\"\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": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS"
  }),
};

$.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": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS"
  })

};
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": "${user.username} your one time password is ${OTP}.",
  "deliveryMethod": "SMS"
})
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": "${user.username} your one time password is ${OTP}.",\n    "deliveryMethod": "SMS"\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": "\${user.username} your one time password is \${OTP}.",
  "deliveryMethod": "SMS"
})

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

```swift
let parameters = "{\n    \"locale\": \"en\",\n    \"variant\": \"variant_C\",\n    \"content\": \"${user.username} your one time password is ${OTP}.\",\n    \"deliveryMethod\": \"SMS\"\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/0a2b9a31-ec7c-4184-aae8-9ea51b789953"
        },
        "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": "0a2b9a31-ec7c-4184-aae8-9ea51b789953",
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    },
    "createdAt": "2021-01-14T00:40:23.107Z",
    "updatedAt": "2021-01-14T00:40:23.107Z",
    "locale": "en",
    "variant": "variant_C",
    "template": {
        "id": "strong_authentication"
    },
    "content": "${user.username} your one time password is ${OTP}.",
    "deliveryMethod": "SMS",
    "default": false
}
```
