> ## Documentation Index
> Fetch the complete documentation index at: https://www.canva.dev/docs/apps/llms.txt
> Use this file to discover all available pages before exploring further.

# Create reply

Reply to a comment on a design.

<Warning>
  This API is currently provided as a preview. Be aware of the following:

  * There might be unannounced breaking changes.
  * Any breaking changes to preview APIs won't produce a new [API version](https://www.canva.dev/docs/apps/rest-apis/versions/).
  * Public apps that use preview APIs will not pass the review process, and can't be made available to all Canva users.
</Warning>

Creates a reply to a comment or suggestion thread on a design.
To reply to an existing thread, you must provide the ID of the thread
which is returned when a thread is created, or from the `thread_id` value
of an existing reply in the thread. Each thread can
have a maximum of 100 replies created for it.

For information on comments and how they're used in the Canva UI, see the
[Canva Help Center](https://www.canva.com/help/comments/).

## HTTP method and URL path

POST https\://api.canva.com/rest/v1/designs/\{designId}/comments/\{threadId}/replies

This operation is rate limited to 20 requests per minute for each user of your app.

## Authentication and authorization

This endpoint requires a valid access token that acts on behalf of a user. For more information, see [Generate an access token](/docs/apps/rest-apis/reference/authentication/generate-access-token).

### Scopes

The access token must have all the following [scopes](/docs/apps/rest-apis/scopes) (permissions):

* `comment:write`

## Header parameters

<Prop.List>
  <Prop name="Authorization" type="string" required>
    Provides credentials to authenticate the request, in the form of a `Bearer` token.

    For example: `Authorization: Bearer {token}`
  </Prop>

  <Prop name="Content-Type" type="string" required>
    Indicates the media type of the information sent in the request. This must be set to `application/json`.

    For example: `Content-Type: application/json`
  </Prop>
</Prop.List>

## Path parameters

<Prop.List>
  <Prop name="designId" type="string" required>
    The design ID.
  </Prop>

  <Prop name="threadId" type="string" required>
    The ID of the thread.
  </Prop>
</Prop.List>

## Body parameters

<Prop.List>
  <Prop name="message_plaintext" type="string" required>
    The comment message of the reply in plaintext. This is the reply comment shown in the Canva UI.

    You can also mention users in your message by specifying their User ID and Team ID
    using the format `[user_id:team_id]`.

    <Prop.Extras>
      **Minimum length:** `1`

      **Maximum length:** `2048`
    </Prop.Extras>
  </Prop>
</Prop.List>

## Example request

Examples for using the `/v1/designs/{designId}/comments/{threadId}/replies` endpoint:

<Tabs storageKey="example.language" disableContentTransition>
  <Tab name="cURL">
    ```sh
    curl --request POST 'https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies' \
    --header 'Authorization: Bearer {token}' \
    --header 'Content-Type: application/json' \
    --data '{
      "message_plaintext": "Thanks!"
    }'
    ```
  </Tab>

  <Tab name="Node.js">
    ```js
    const fetch = require("node-fetch");

    fetch("https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies", {
      method: "POST",
      headers: {
        "Authorization": "Bearer {token}",
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        "message_plaintext": "Thanks!"
      }),
    })
      .then(async (response) => {
        const data = await response.json();
        console.log(data);
      })
      .catch(err => console.error(err));
    ```
  </Tab>

  <Tab name="Java">
    ```java
    import java.io.IOException;
    import java.net.URI;
    import java.net.http.*;

    public class ApiExample {
        public static void main(String[] args) throws IOException, InterruptedException {
            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies"))
                .header("Authorization", "Bearer {token}")
                .header("Content-Type", "application/json")
                .method("POST", HttpRequest.BodyPublishers.ofString("{\"message_plaintext\": \"Thanks!\"}"))
                .build();

            HttpResponse<String> response = HttpClient.newHttpClient().send(
                request,
                HttpResponse.BodyHandlers.ofString()
            );
            System.out.println(response.body());
        }
    }
    ```
  </Tab>

  <Tab name="Python">
    ```py
    import requests

    headers = {
        "Authorization": "Bearer {token}",
        "Content-Type": "application/json"
    }

    data = {
        "message_plaintext": "Thanks!"
    }

    response = requests.post("https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies",
        headers=headers,
        json=data
    )
    print(response.json())
    ```
  </Tab>

  <Tab name="C#">
    ```csharp
    using System.Net.Http;

    var client = new HttpClient();
    var request = new HttpRequestMessage
    {
      Method = HttpMethod.Post,
      RequestUri = new Uri("https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies"),
      Headers =
      {
        { "Authorization", "Bearer {token}" },
      },
      Content = new StringContent(
        "{\"message_plaintext\": \"Thanks!\"}",
        Encoding.UTF8,
        "application/json"
      ),
    };

    using (var response = await client.SendAsync(request))
    {
      response.EnsureSuccessStatusCode();
      var body = await response.Content.ReadAsStringAsync();
      Console.WriteLine(body);
    };
    ```
  </Tab>

  <Tab name="Go">
    ```go
    package main

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

    func main() {
    	payload := strings.NewReader(`{
    	  "message_plaintext": "Thanks!"
    	}`)

    	url := "https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies"
    	req, _ := http.NewRequest("POST", url, payload)
    	req.Header.Add("Authorization", "Bearer {token}")
    	req.Header.Add("Content-Type", "application/json")

    	res, _ := http.DefaultClient.Do(req)
    	defer res.Body.Close()
    	body, _ := io.ReadAll(res.Body)
    	fmt.Println(string(body))
    }
    ```
  </Tab>

  <Tab name="PHP">
    ```php
    $curl = curl_init();
    curl_setopt_array($curl, array(
      CURLOPT_URL => "https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies",
      CURLOPT_CUSTOMREQUEST => "POST",
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_HTTPHEADER => array(
        'Authorization: Bearer {token}',
        'Content-Type: application/json',
      ),
      CURLOPT_POSTFIELDS => json_encode([
        "message_plaintext" => "Thanks!"
      ])
    ));

    $response = curl_exec($curl);
    $err = curl_error($curl);
    curl_close($curl);

    if (empty($err)) {
      echo $response;
    } else {
      echo "Error: " . $err;
    }
    ```
  </Tab>

  <Tab name="Ruby">
    ```ruby
    require 'net/http'
    require 'uri'

    url = URI('https://api.canva.com/rest/v1/designs/{designId}/comments/{threadId}/replies')
    http = Net::HTTP.new(url.host, url.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(url)
    request['Authorization'] = 'Bearer {token}'
    request['Content-Type'] = 'application/json'
    request.body = <<REQUEST_BODY
    {
      "message_plaintext": "Thanks!"
    }
    REQUEST_BODY

    response = http.request(request)
    puts response.read_body
    ```
  </Tab>
</Tabs>

## Success response

If successful, the endpoint returns a `200` response with a JSON body with the following parameters:

<Prop.List>
  <Prop name="reply" type="Reply" required mode="output">
    A reply to a thread.

    The `author` of the reply might be missing if that user account no longer exists.

    <PillAccordion title={<>Properties of <strong>reply</strong></>} defaultExpanded={true}>
      <Prop.List>
        <Prop name="id" type="string" required mode="output">
          The ID of the reply.
        </Prop>

        <Prop name="design_id" type="string" required mode="output">
          The ID of the design that the thread for this reply is attached to.
        </Prop>

        <Prop name="thread_id" type="string" required mode="output">
          The ID of the thread this reply is in.
        </Prop>

        <Prop name="content" type="CommentContent" required mode="output">
          The content of a comment thread or reply.

          <PillAccordion title={<>Properties of <strong>content</strong></>}>
            <Prop.List>
              <Prop name="plaintext" type="string" required mode="output">
                The content in plaintext.
                Any user mention tags are shown in the format `[user_id:team_id]`.
              </Prop>

              <Prop name="markdown" type="string" mode="output">
                The content in markdown.
                Any user mention tags are shown in the format `[user_id:team_id]`
              </Prop>
            </Prop.List>
          </PillAccordion>
        </Prop>

        <Prop name="mentions" type="object" required mode="output">
          The Canva users mentioned in the comment thread or reply.

          <PillAccordion title={<>Properties of <strong>mentions</strong></>}>
            <Prop.List>
              <Prop name="<KEY>" type="object of UserMentions" mode="output" required required>
                Information about the user mentioned in a comment thread or reply. Each user mention is keyed using the user's user ID and team ID separated by a colon (`user_id:team_id`).

                ```json
                {
                  "oUnPjZ2k2yuhftbWF7873o:oBpVhLW22VrqtwKgaayRbP": {
                    "tag": "oUnPjZ2k2yuhftbWF7873o:oBpVhLW22VrqtwKgaayRbP",
                    "user": {
                      "user_id": "oUnPjZ2k2yuhftbWF7873o",
                      "team_id": "oBpVhLW22VrqtwKgaayRbP",
                      "display_name": "John Doe"
                    }
                  }
                }
                ```

                <Prop.List>
                  <Prop name="tag" type="string" required mode="output">
                    The mention tag for the user mentioned in the comment thread or reply content. This has the format of the user's user ID and team ID separated by a colon (`user_id:team_id`).
                  </Prop>

                  <Prop name="user" type="TeamUser" required mode="output">
                    Metadata for the user, consisting of the User ID, Team ID, and display name.

                    <PillAccordion title={<>Properties of <strong>user</strong></>}>
                      <Prop.List>
                        <Prop name="user_id" type="string" mode="output">
                          The ID of the user.
                        </Prop>

                        <Prop name="team_id" type="string" mode="output">
                          The ID of the user's Canva Team.
                        </Prop>

                        <Prop name="display_name" type="string" mode="output">
                          The name of the user as shown in the Canva UI.
                        </Prop>
                      </Prop.List>
                    </PillAccordion>
                  </Prop>
                </Prop.List>
              </Prop>
            </Prop.List>
          </PillAccordion>
        </Prop>

        <Prop name="created_at" type="integer" required mode="output">
          When the reply was created, as a Unix timestamp
          (in seconds since the Unix Epoch).
        </Prop>

        <Prop name="updated_at" type="integer" required mode="output">
          When the reply was last updated, as a Unix timestamp
          (in seconds since the Unix Epoch).
        </Prop>

        <Prop name="author" type="User" mode="output">
          Metadata for the user, consisting of the User ID and display name.

          <PillAccordion title={<>Properties of <strong>author</strong></>}>
            <Prop.List>
              <Prop name="id" type="string" required mode="output">
                The ID of the user.
              </Prop>

              <Prop name="display_name" type="string" mode="output">
                The name of the user as shown in the Canva UI.
              </Prop>
            </Prop.List>
          </PillAccordion>
        </Prop>
      </Prop.List>
    </PillAccordion>
  </Prop>
</Prop.List>

## Example response

```json
{
  "reply": {
    "id": "KeAZEAjijEb",
    "design_id": "DAFVztcvd9z",
    "thread_id": "KeAbiEAjZEj",
    "author": {
      "id": "uKakKUfI03Fg8k2gZ6OkT",
      "display_name": "John Doe"
    },
    "content": {
      "plaintext": "Great work [oUnPjZ2k2yuhftbWF7873o:oBpVhLW22VrqtwKgaayRbP]!",
      "markdown": "*_Great work_* [oUnPjZ2k2yuhftbWF7873o:oBpVhLW22VrqtwKgaayRbP]!"
    },
    "mentions": {
      "oUnPjZ2k2yuhftbWF7873o:oBpVhLW22VrqtwKgaayRbP": {
        "tag": "oUnPjZ2k2yuhftbWF7873o:oBpVhLW22VrqtwKgaayRbP",
        "user": {
          "user_id": "oUnPjZ2k2yuhftbWF7873o",
          "team_id": "oBpVhLW22VrqtwKgaayRbP",
          "display_name": "John Doe"
        }
      }
    },
    "created_at": 1692929800,
    "updated_at": 1692929900
  }
}
```

## Error responses

### 400 Bad Request

<Prop.List>
  <Prop name="code" type="string" required mode="output">
    A short string indicating what failed. This field can be used to handle errors programmatically. For a complete list of error codes, see [Error responses](/docs/apps/rest-apis/error-responses/).
  </Prop>

  <Prop name="message" type="string" required mode="output">
    A human-readable description of what went wrong.
  </Prop>
</Prop.List>

#### Example error responses

##### Message is too long

```json
{
  "code": "message_too_long",
  "message": "Message is too long"
}
```

##### Mentions with non-obfuscated IDs are not allowed for this client

```json
{
  "code": "invalid_field",
  "message": "Invalid IDs"
}
```

### 403 Forbidden

<Prop.List>
  <Prop name="code" type="string" required mode="output">
    A short string indicating what failed. This field can be used to handle errors programmatically. For a complete list of error codes, see [Error responses](/docs/apps/rest-apis/error-responses/).
  </Prop>

  <Prop name="message" type="string" required mode="output">
    A human-readable description of what went wrong.
  </Prop>
</Prop.List>

#### Example error responses

##### This comment thread already has the maximum number of allowed replies

```json
{
  "code": "too_many_replies",
  "message": "This comment thread already has the maximum number of allowed replies"
}
```

##### Not allowed to reply on this design

```json
{
  "code": "permission_denied",
  "message": "Not allowed to reply on this design"
}
```

### 404 Not Found

<Prop.List>
  <Prop name="code" type="string" required mode="output">
    A short string indicating what failed. This field can be used to handle errors programmatically. For a complete list of error codes, see [Error responses](/docs/apps/rest-apis/error-responses/).
  </Prop>

  <Prop name="message" type="string" required mode="output">
    A human-readable description of what went wrong.
  </Prop>
</Prop.List>

#### Example error responses

##### Design or comment not found

```json
{
  "code": "design_not_found",
  "message": "Design or comment not found"
}
```

##### A mentioned user could not be found

```json
{
  "code": "user_not_found",
  "message": "Invalid user ID"
}
```

##### A mentioned user's team could not be found

```json
{
  "code": "team_not_found",
  "message": "Invalid brand ID"
}
```