# Update Task Progress from Another Tool

> When work moves forward in another tool (for example Jira, Asana or a help desk), mark the linked Task Completed, change its Assignee or Due Date, and add a comment.

This is the Markdown copy of https://api.exhibitday.com/Help/V1?guide=update-task-progress for AI tools. Code examples are in curl, JavaScript, Python and C#; the help page shows all 8 languages, and https://api.exhibitday.com/llms-full.txt has the complete reference in one file. Index of all pages: https://api.exhibitday.com/llms.txt

When work moves forward in another tool (for example Jira, Asana or a help desk), mark the linked Task Completed, change its Assignee or Due Date, and add a comment.

Example use case

A Jira issue for the booth graphics is closed. Your integration marks the linked ExhibitDay Task Completed and adds a comment that names the issue.

What you'll end up with

The Task's new completion status, Assignee or Due Date, and a new comment on the Task.

Before you start

Have a workspace API key and a Task linked to your tool's record. [Create Tasks from Forms, Tickets or Other Apps](https://api.exhibitday.com/Help/V1?guide=create-tasks) creates one. Save your tool's ID in `integration_metadata_field_1` when you create it.

Good to know

Send only the fields you want to change. The revision check refuses your update if someone changed the Task since you read it.

## At a glance

Time to try

About 10 minutes

Effect on your data

Updates records

Endpoints

5

The example marks one Task Completed. Steps 5 and 6 change a Task and add a comment. ExhibitDay sends the same emails as when someone makes these changes on the website.

- [`GET /v1/tasks`](https://api.exhibitday.com/Help/V1?epf=2#get-v1-tasks)
- [`GET /v1/tasks/info`](https://api.exhibitday.com/Help/V1?epf=2#get-v1-tasks-info)
- [`PATCH /v1/tasks`](https://api.exhibitday.com/Help/V1?epf=2#patch-v1-tasks)
- [`GET /v1/references/users_and_resources`](https://api.exhibitday.com/Help/V1?epf=3#get-v1-references-users_and_resources)
- [`POST /v1/tasks/comments`](https://api.exhibitday.com/Help/V1?epf=2&amp;topic=comments#post-v1-tasks-comments)

## How it works

1. Find the Task by your tool's ID and read its current revision.
2. Save the new status, Assignee or Due Date with that revision. A conflict saves nothing.
3. Add a comment, then read the Task again to confirm.

## Update the linked Task

## Step 1: Find the Task linked to your record

Search the integration field where you saved your tool's ID. This example looks for `JIRA-4821`.

```bash
curl -X GET "https://api.exhibitday.com/v1/tasks?filter_by_integration_metadata_field_1=JIRA-4821&%24return_task_lites=true" -H "Authorization: Bearer YOUR_API_KEY"
```

**Example response (shortened)**

```json
{
  "records_found": 1,
  "total_records": 1,
  "has_more": false,
  "list_data": [
    {
      "id": 12345,
      "name": "Sample task",
      "is_completed": false,
      "integration_metadata_field_1": ""
    }
  ]
}
```

**Check:** Expect exactly one match. The filter matches the whole value and ignores letter case and spaces before or after it. If you kept the Task `id` when you created it, skip this step.

## Step 2: Read the Task and its revision

Read the current values so the update can detect changes made since your read.

```bash
curl -X GET "https://api.exhibitday.com/v1/tasks/info?id=34567&%24include_record_revision=true" -H "Authorization: Bearer YOUR_API_KEY"
```

**Check:** Keep `record_revision` exactly as returned. If `is_completed` already has the value you want, there's nothing to save.

## Step 3: Mark the Task Completed

Send `is_completed` with `expected_revision` set to the `record_revision` from Step 2, in place of `YOUR_RECORD_REVISION`. Send `false` to reopen a Completed Task (mark it Incomplete).

```bash
curl -X PATCH "https://api.exhibitday.com/v1/tasks" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"id\":34567,\"is_completed\":true,\"expected_revision\":\"YOUR_RECORD_REVISION\"}"
```

**Example response (shortened)**

```json
{
  "status_code": 200,
  "status": "OK",
  "message": "Task Update Successful. Task properties that were changed: is_completed"
}
```

**Check:** `message` lists the Task properties that changed. If you get `record_changed` (HTTP 409), the update saved nothing. Read the Task again and decide whether your change is still needed.

## Step 4: Confirm the new Assignee, if you change it

List the people who can be assigned Tasks. Tasks can't be assigned to Resources.

```bash
curl -X GET "https://api.exhibitday.com/v1/references/users_and_resources?filter_by_can_have_tasks_assigned=true" -H "Authorization: Bearer YOUR_API_KEY"
```

**Example response (shortened)**

```json
{
  "list_data": [
    {
      "id": "11111111-2222-4333-8444-555555555555",
      "display_name": "Jane Smith",
      "can_have_tasks_assigned": true
    }
  ]
}
```

**Check:** The new Assignee's `id` appears in `list_data`. Treat the ID as text.

## Step 5: Reassign the Task or move its Due Date

Use the same request with the fields you want to change. Leave out a field to keep it. Send `expected_revision` from a fresh read, because the Task's revision changed in Step 3.

```bash
curl -X PATCH "https://api.exhibitday.com/v1/tasks" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"id\":34567,\"assignee_user_id\":\"11111111-2222-4333-8444-555555555555\",\"due_date\":\"2027-03-05\",\"expected_revision\":\"YOUR_RECORD_REVISION\"}"
```

| To | Send |
| --- | --- |
| Assign someone else | `assignee_user_id` with their user ID |
| Unassign the Task | `assignee_user_id` with `null` |
| Change the Due Date | `due_date` as `YYYY-MM-DD` |
| Remove the Due Date | `due_date` with `null` |

**Check:** An empty value leaves the field as it is, and the response's `warnings` list names it. Assigning someone who can't be assigned Tasks, such as a Resource, returns `invalid_request` (HTTP 400).

## Step 6: Add a comment

Post a short note in plain text. Add the header `Idempotency-Key: YOUR_UNIQUE_KEY` so a retry can reuse the original result.

```bash
curl -X POST "https://api.exhibitday.com/v1/tasks/comments" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"task_id\":34567,\"comment\":\"Closed in Jira: JIRA-4821\"}"
```

**Example response (shortened)**

```json
{
  "id": 23456,
  "comment": "Closed in Jira: JIRA-4821",
  "task_id": 34567
}
```

**Check:** Save the comment `id`. Line breaks show as line breaks in ExhibitDay. To confirm the Task's saved values, read it again as in Step 2.

## Try it

## Before running the example

| Value | What to put in it |
| --- | --- |
| `YOUR_API_KEY` | Your workspace API key. Keep it out of shared code and logs. |
| `id` | The ID of a test Task, from Step 1. The example uses `34567`. |
| `is_completed` | `true` to mark the Task Completed, or `false` to mark it Incomplete. The example sends `true`. |
| `expected_revision` | Replace `YOUR_RECORD_REVISION` with the `record_revision` from Step 2. Leave it out to skip the revision check. |

**Careful.** This example changes an existing Task, and ExhibitDay may email people about it. Use a test Task.

Copy the complete example in your language and run it. To try another step, change the request to match one of the steps above.

## Complete example program

Code Samples

```bash
curl -X PATCH "https://api.exhibitday.com/v1/tasks" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"id\":34567,\"is_completed\":true,\"expected_revision\":\"YOUR_RECORD_REVISION\"}"
```

```javascript
const response = await fetch("https://api.exhibitday.com/v1/tasks", {
  method: "PATCH",
  headers: { "Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ "id": 34567, "is_completed": true, "expected_revision": "YOUR_RECORD_REVISION" })
});
const data = await response.json();
console.log(response.status, data);
```

```python
import requests

response = requests.patch(
    "https://api.exhibitday.com/v1/tasks",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"id": 34567, "is_completed": True, "expected_revision": "YOUR_RECORD_REVISION"},
)
print(response.status_code, response.json())
```

```csharp
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Http.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "YOUR_API_KEY");
var response = await client.PatchAsync("https://api.exhibitday.com/v1/tasks",
    JsonContent.Create(new { id = 34567, is_completed = true, expected_revision = "YOUR_RECORD_REVISION" }));
Console.WriteLine($"{(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");
```

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ExhibitDayExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.exhibitday.com/v1/tasks"))
            .header("Authorization", "Bearer YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .method("PATCH", HttpRequest.BodyPublishers.ofString("{\"id\":34567,\"is_completed\":true,\"expected_revision\":\"YOUR_RECORD_REVISION\"}"))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.statusCode() + " " + response.body());
    }
}
```

```php
<?php
$curl = curl_init('https://api.exhibitday.com/v1/tasks');
curl_setopt_array($curl, [
    CURLOPT_CUSTOMREQUEST => 'PATCH',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer YOUR_API_KEY', 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS => '{"id":34567,"is_completed":true,"expected_revision":"YOUR_RECORD_REVISION"}',
]);
$response = curl_exec($curl);
if ($response === false) {
    throw new RuntimeException(curl_error($curl));
}
echo curl_getinfo($curl, CURLINFO_HTTP_CODE) . PHP_EOL . $response;
curl_close($curl);
```

```ruby
require 'net/http'
require 'uri'

uri = URI('https://api.exhibitday.com/v1/tasks')
request = Net::HTTP::Patch.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = '{"id":34567,"is_completed":true,"expected_revision":"YOUR_RECORD_REVISION"}'
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
puts "#{response.code} #{response.body}"
```

```go
package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "strings"
)

func main() {
    request, err := http.NewRequest("PATCH", "https://api.exhibitday.com/v1/tasks", strings.NewReader("{\"id\":34567,\"is_completed\":true,\"expected_revision\":\"YOUR_RECORD_REVISION\"}"))
    if err != nil { log.Fatal(err) }
    request.Header.Set("Authorization", "Bearer YOUR_API_KEY")
    request.Header.Set("Content-Type", "application/json")
    response, err := (&http.Client{}).Do(request)
    if err != nil { log.Fatal(err) }
    defer response.Body.Close()
    body, err := io.ReadAll(response.Body)
    if err != nil { log.Fatal(err) }
    fmt.Printf("%d %s\n", response.StatusCode, body)
}
```

## Example response

Response 200 — OK 400 — Bad Request 401 — Unauthorized 404 — Not Found 409 — Conflict 429 — Too Many Requests 500 — Internal Server Error

Example Successful request

```json
{
  "status_code": 200,
  "status": "OK",
  "message": "Task Update Successful. Task properties that were changed: is_completed",
  "errors": []
}
```

Note: PATCH /v1/tasks - HTTP 200. The Task was marked Completed. The message names the properties that changed. With expected_revision, the live response also returns the Task's new record_revision.

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "HTTP method override is not supported.",
  "error_code": "invalid_request",
  "errors": [
    "Send the documented HTTP method directly. X-HTTP-Method-Override cannot change a request's HTTP method."
  ],
  "error_params": [
    "X-HTTP-Method-Override"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "Invalid value for the contributor_user_ids parameter. Each contributor must be a current workspace user who can be assigned tasks. You can get a list of users in your workspace from the /v1/references/users_and_resources endpoint.",
  "error_code": "invalid_request",
  "errors": [
    "Invalid value for the contributor_user_ids parameter. Each contributor must be a current workspace user who can be assigned tasks. You can get a list of users in your workspace from the /v1/references/users_and_resources endpoint."
  ],
  "error_params": [
    "contributor_user_ids"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "Invalid value for the contributor_user_ids parameter. Send a JSON array of unique user IDs, for example [\"user-id\",\"other-user-id\"], or one user ID. Send null or [] to remove all contributors.",
  "error_code": "invalid_request",
  "errors": [
    "Invalid value for the contributor_user_ids parameter. Send a JSON array of unique user IDs, for example [\"user-id\",\"other-user-id\"], or one user ID. Send null or [] to remove all contributors."
  ],
  "error_params": [
    "contributor_user_ids"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 401,
  "status": "Unauthorized",
  "message": "No API key was provided. Send your key in the Authorization header as 'Bearer YOUR_API_KEY'. Alternatively, you can use the api_key parameter.",
  "error_code": "missing_api_key",
  "errors": [
    "Copy the key from Workspace Settings > API & Integrations > API Access in ExhibitDay."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 401,
  "status": "Unauthorized",
  "message": "The API key is not valid. Check that you copied the whole key from Workspace Settings > API & Integrations > API Access, then send it in the Authorization header as 'Bearer YOUR_API_KEY'. Alternatively, you can use the api_key parameter.",
  "error_code": "invalid_api_key",
  "errors": [
    "Check that you sent the whole key. If it was regenerated, use the current key from Workspace Settings > API & Integrations > API Access."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 401,
  "status": "Unauthorized",
  "message": "Access to the ExhibitDay API is not enabled for your workspace. Please contact support@exhibitday.com to enable API Access. Once access is enabled, send your key in the Authorization header as 'Bearer YOUR_API_KEY'.",
  "error_code": "api_access_disabled",
  "errors": [
    "Nothing was read or changed."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 404,
  "status": "Not Found",
  "message": "Task not found. Invalid Task ID: 12345.",
  "error_code": "not_found",
  "errors": [
    "Task not found. Invalid Task ID: 12345."
  ],
  "error_params": [
    "id"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 409,
  "status": "Conflict",
  "message": "This record changed since you read it. Read it again, review the changes and decide whether to retry; nothing was changed.",
  "error_code": "record_changed",
  "errors": [
    "This record changed since you read it. Read it again, review the changes and decide whether to retry; nothing was changed."
  ],
  "error_params": [
    "expected_revision"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 429,
  "status": "Too Many Requests",
  "message": "Error 429 - Too Many Requests",
  "error_code": "rate_limited",
  "errors": [
    "Error 429 - Too Many Requests"
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 500,
  "status": "Unexpected Internal Error",
  "message": "An unexpected error occurred. Please try again later.",
  "error_code": "internal_error",
  "errors": [
    "An unexpected error occurred. Please try again later."
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

Note: Use the request_id from your own response when contacting support.

```json
{
  "status_code": 500,
  "status": "Unexpected Internal Error",
  "message": "An unexpected error occurred. Please try again later.",
  "error_code": "internal_error",
  "errors": [
    "Check whether your change was saved before trying again."
  ],
  "error_params": [],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

The curl example uses Bash. Node.js needs version 18 or later (save as .mjs). Python uses Requests. C# needs a .NET 8 console project (Program.cs). Java needs Java 11 or later (ExhibitDayExample.java). PHP needs PHP with cURL. Ruby and Go use their standard libraries.

## Things to keep in mind

- The API sends the same emails as the website. Completing a Task emails its Creator, Assignee and Contributors. Assigning it emails the new Assignee. A comment emails the Creator, Assignee and Contributors. Each person gets these only if their email preferences allow it, and the person who made the change doesn't get one.
- If the Event's lock settings include “Also prevent this event's tasks from being modified outside the event, via the main Task Board” (under Lock the Tasks tab in Lock Event), the API returns `not_allowed` for its Tasks. Change that setting in ExhibitDay before you retry.
- If you lose the comment's response, retry the exact request with the same key. For 24 hours, a completed request can return the saved response with `Idempotent-Replayed: true`.
- If the API returns `idempotency_key_indeterminate`, list the Task's comments with `GET /v1/tasks/comments` and `filter_by_task_id` before deciding whether to post again.
- More than one Task can share an integration value. Stop and check if Step 1 returns more than one.

## Related guides

- [Create Tasks from Forms, Tickets or Other Apps](https://api.exhibitday.com/Help/V1?guide=create-tasks)
- [Avoid Overwriting Someone Else's Changes](https://api.exhibitday.com/Help/V1?guide=update-records-safely)
- [Search Tasks by Name, Details, Assignee and Due Date](https://api.exhibitday.com/Help/V1?guide=search-tasks)
- [Handle Errors and Retry Failed Requests](https://api.exhibitday.com/Help/V1?guide=errors-and-retries)
