> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.projectmanager.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.projectmanager.com/_mcp/server.

# Query Resource Workload

GET https://api.projectmanager.com/api/data/workload/resources/{resourceId}

Retrieve information about the expected workload for a Resource.  The workload for a Resource is a list of
tasks, days, and the amount of time spent on each task per day.  You can examine a Resource's workload to
identify when that Resource is required to contribute to specific tasks.
            
To query for workload for a Resource, you must first know the unique identifier of the Resource.  You may
use the QueryResource API to identify the resource, and then use its `id` field to call `QueryResourceWorkload`.
            
Workload is defined in two ways: either automatically by the ProjectManager.com system, or manually by editing
the workload page within the ProjectManager.com app.  When you query for workload information, each entry will
specify whether the assignment was created manually or via the system.  If a task does not have any workload
allocated, it will not be returned by this API.
            
The `QueryResourceWorkload` API uses Gridify-style querying. For a full description of query rules, see
[Querying Tutorial](https://developer.projectmanager.com/getting-started/querying-tutorial).  When querying
for workload, you can use filters, sorting, pagination, and you can also request additional
data to be included in the API result.  The QueryResourceWorkload API returns a maximum of 1000 results per
request as a single page.  To retrieve all workload for a Resource, you must fetch pages starting with the
number 1 until no additional data is returned.

Reference: https://developer.projectmanager.com/api-reference/workload/query-resource-workload

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `resourceId` (string, required) — The id of the Resource

### Query parameters

- `filter` (string, optional) — A Gridify formatted filter used to search by `task.projectId` and/or `date` and/or `minutes`
- `sort` (string, optional) — A Gridify formatted ordering used to sort by `date`, `task.name` and/or `createdDate`. Defaults to `date asc`.
- `include` (string, optional) — A comma separated list of additional data to include in each result. Set to `task` to include basic Task details, and/or `assignment` to include the assignment's total assigned minutes.
- `page` (integer, optional, default: 1) — The page number to retrieve, starting at 1. Defaults to 1. Pages over individual allocations.
- `pageSize` (integer, optional, default: 1000) — The number of allocations, no less than 1 or more than 1000, per page. Defaults to 1000.

### Headers

- `x-integration-name` (string, optional) — The name of the calling system passed along as a header parameter

## Response

### 200

Success

- `error` (AstroError, optional, nullable) — If the API call failed, this will contain information about the error that occurred.
- `success` (boolean, optional) — True if the API call succeeded; false otherwise.
- `hasError` (boolean, optional) — True if the API call failed.
- `statusCode` (enum, optional) — The HTTP code of the response.
  - Allowed values: `Continue`, `SwitchingProtocols`, `Processing`, `EarlyHints`, `OK`, `Created`, `Accepted`, `NonAuthoritativeInformation`, `NoContent`, `ResetContent`, `PartialContent`, `MultiStatus`, `AlreadyReported`, `IMUsed`, `MultipleChoices`, `MovedPermanently`, `Found`, `SeeOther`, `NotModified`, `UseProxy`, `Unused`, `TemporaryRedirect`, `PermanentRedirect`, `BadRequest`, `Unauthorized`, `PaymentRequired`, `Forbidden`, `NotFound`, `MethodNotAllowed`, `NotAcceptable`, `ProxyAuthenticationRequired`, `RequestTimeout`, `Conflict`, `Gone`, `LengthRequired`, `PreconditionFailed`, `RequestEntityTooLarge`, `RequestUriTooLong`, `UnsupportedMediaType`, `RequestedRangeNotSatisfiable`, `ExpectationFailed`, `MisdirectedRequest`, `UnprocessableEntity`, `Locked`, `FailedDependency`, `UpgradeRequired`, `PreconditionRequired`, `TooManyRequests`, `RequestHeaderFieldsTooLarge`, `UnavailableForLegalReasons`, `InternalServerError`, `NotImplemented`, `BadGateway`, `ServiceUnavailable`, `GatewayTimeout`, `HttpVersionNotSupported`, `VariantAlsoNegotiates`, `InsufficientStorage`, `LoopDetected`, `NotExtended`, `NetworkAuthenticationRequired`
- `data` (list of ResourceWorkloadAllocationDto, optional) — If the API call succeeded, this will contain the results.

## Types

### AstroError

Information about an error that occurred within the ProjectManager API.

- `technicalError` (string, optional, nullable) — A technical description of the error that occurred. Not suitable for display to end users.
- `additionalErrors` (list of string, optional, nullable) — If additional errors beyond the main error in `Message` occurred, they will be listed here as individual messages.
- `validationErrors` (map from string to list of string, optional, nullable) — This contains a dictionary of validation errors. The key is the name of the field
- `message` (string, optional, nullable) — A description of the error that occurred. If your application has a user interface, show this message to explain what went wrong.

### ResourceWorkloadAllocationDto

A single planned allocation for a Resource on a Task, on a specific date.

- `id` (string, optional) — The unique identifier of this allocation, which is a combination of the TaskAssignmentId and the Date.
- `taskId` (string, optional) — The unique identifier of the Task this allocation belongs to.
- `taskAssignmentId` (string, optional) — The unique identifier of the TaskAssignment this allocation belongs to.
- `date` (string, optional) — The date this allocation applies to.
- `minutes` (integer, optional) — The number of minutes assigned on this date.
- `isSystem` (boolean, optional) — True if this allocation was generated by the system rather than manually set.
- `task` (ResourceWorkloadTaskDetailsDto, optional, nullable) — Basic details about the Task. Only populated when the request specifies `include=task`.
- `assignment` (ResourceWorkloadTaskAssignmentDto, optional, nullable) — Details about the TaskAssignment. Only populated when the request specifies `include=taskAssignment`.

### ResourceWorkloadTaskDetailsDto

Basic details of the Task a workload entry belongs to. Only populated when the request specifies `include=task`.

- `id` (string, optional) — The unique identifier of the Task.
- `projectId` (string, optional, nullable) — The unique identifier of the Project this Task belongs to.
- `name` (string, optional) — The name of the Task.
- `description` (string, optional, nullable) — The Task's description, in markdown format.
- `percentComplete` (integer, optional, nullable) — The percentage of the task duration completed.
- `plannedStartDate` (string, optional) — The planned start date of the Task.
- `plannedFinishDate` (string, optional, nullable) — The planned finish date of the Task.
- `actualStartDate` (string, optional, nullable) — The actual start date of the Task.
- `actualFinishDate` (string, optional, nullable) — The actual finish date of the Task.
- `status` (TaskStatusDto, optional, nullable) — The Task's current status (board column).
- `tags` (list of TaskTagDto, optional) — The TaskTags that apply to this Task.

### ResourceWorkloadTaskAssignmentDto

Details about the TaskAssignment a workload allocation belongs to. Only populated when the request specifies `include=taskAssignment`.

- `id` (string, optional) — The unique identifier of the TaskAssignment.
- `totalAssignedMinutes` (integer, optional) — The total number of minutes assigned to this Resource across all of this TaskAssignment's allocations.

### TaskStatusDto

A TaskStatus is a named status level used by your business to determine how to measure the progress of Tasks. You can define your own named status levels that are appropriate for your business and determine which status levels are considered done.

- `id` (string, optional) — The unique identifier of this TaskStatus.
- `projectId` (string, optional) — The unique identifier of the Project to which this TaskStatus belongs.
- `name` (string, optional) — The name of this TaskStatus.
- `order` (integer, optional) — A numerical value that can be used to sort TaskStatus values according to the needs of your business.
- `isDone` (boolean, optional) — True if a Task in this TaskStatus is considered done.

### TaskTagDto

A TaskTag is a connection between a Task and a Tag. Each Task can have zero, one or many TaskTags associated with it. TaskTags can be assigned and removed from the Task to help you classify your Tasks and prioritize work.

- `id` (string, optional) — The unique identifier of this TaskTag.
- `name` (string, optional) — The common name of this TaskTag.
- `color` (string, optional) — The color that will be used to represent this Tag visually. This color is automatically chosen by the application when a user creates a Tag. You can choose specify any color that can be represented using HTML RGB syntax such as `#0088FF`, in the format `RRGGBB`. You may not use names for colors.

## Examples

**Response**

```json
{
  "error": {
    "technicalError": "string",
    "additionalErrors": [
      "string"
    ],
    "validationErrors": {},
    "message": "string"
  },
  "success": true,
  "hasError": true,
  "statusCode": "Continue",
  "data": [
    {
      "id": "string",
      "taskId": "string",
      "taskAssignmentId": "string",
      "date": "2023-01-15",
      "minutes": 1,
      "isSystem": true,
      "task": {
        "id": "string",
        "projectId": "string",
        "name": "string",
        "description": "string",
        "percentComplete": 1,
        "plannedStartDate": "2023-01-15",
        "plannedFinishDate": "2023-01-15",
        "actualStartDate": "2023-01-15",
        "actualFinishDate": "2023-01-15",
        "status": {
          "id": "string",
          "projectId": "string",
          "name": "string",
          "order": 1,
          "isDone": true
        },
        "tags": [
          {
            "id": "string",
            "name": "string",
            "color": "string"
          }
        ]
      },
      "assignment": {
        "id": "string",
        "totalAssignedMinutes": 1
      }
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.projectmanager.com/api/data/workload/resources/resourceId"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.projectmanager.com/api/data/workload/resources/resourceId';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://api.projectmanager.com/api/data/workload/resources/resourceId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.projectmanager.com/api/data/workload/resources/resourceId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.projectmanager.com/api/data/workload/resources/resourceId")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.projectmanager.com/api/data/workload/resources/resourceId', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.projectmanager.com/api/data/workload/resources/resourceId");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.projectmanager.com/api/data/workload/resources/resourceId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```