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

# Clients

> Create clients, list and fetch them, and add documents to a client's binder

A **client** is a taxpayer or return that lives inside a workspace. Every client
operation is reached through the [`me`](/apis/me) query resolved as a
`WorkspaceUser`, so you must authenticate with a **`workspaceToken`** (see
[Authentication](/guides/authentication)). All requests go to:

```
https://router.apps.filed.com/graphql
```

<Note>
  There is no top-level `clients` query. Clients belong to a workspace, so you read
  them through `me { ... on WorkspaceUser { workspace { clients(...) } } }`. The
  `workspaceToken` already identifies which workspace, so you never pass a
  workspace ID.
</Note>

## The `Client` type

```graphql theme={null}
type Client {
  id: ID!
  name: String!
  externalId: String!
  status: ClientStatus!
  returnType: ReturnType!
  taxYear: Int!
  createdAt: Date!
  assignees: [WorkspaceUserShortDetails!]!
  tasks(type: TaskType, status: TaskStatus, triggeredBy: ID, limit: Int): [Task!]!
}

enum ClientStatus {
  active
  archived
}

enum ReturnType {
  F1040
  F1041
  F1065
  F1120
  F1120S
  F990
}
```

<ResponseField name="id" type="ID!">
  The client's unique identifier.
</ResponseField>

<ResponseField name="name" type="String!">
  The client's display name.
</ResponseField>

<ResponseField name="externalId" type="String!">
  Your own identifier for the client (for example the ID from your practice
  management system). Unique within the workspace.
</ResponseField>

<ResponseField name="status" type="ClientStatus!">
  `active` or `archived`.
</ResponseField>

<ResponseField name="returnType" type="ReturnType!">
  The tax return form: `F1040`, `F1041`, `F1065`, `F1120`, `F1120S`, or `F990`.
</ResponseField>

<ResponseField name="taxYear" type="Int!">
  The tax year, for example `2025`.
</ResponseField>

<ResponseField name="createdAt" type="Date!">
  When the client was created.
</ResponseField>

<ResponseField name="assignees" type="[WorkspaceUserShortDetails!]!">
  The workspace users assigned to this client.

  ```graphql theme={null}
  type WorkspaceUserShortDetails {
    id: ID!
    userId: ID!
    name: String!
    email: String
    role: WorkspaceRole!
    kind: UserKind
    createdAt: Date
    invitedByName: String
    invitedByEmail: String
  }

  enum WorkspaceRole {
    admin
    l1
    l2
    l3
  }

  enum UserKind {
    user
    backoffice_user
    assistant
    api
  }
  ```

  <Expandable title="fields">
    <ResponseField name="id" type="ID!">The membership ID (workspace user), not the underlying user ID.</ResponseField>
    <ResponseField name="userId" type="ID!">The underlying user account ID.</ResponseField>
    <ResponseField name="name" type="String!">The user's display name.</ResponseField>
    <ResponseField name="email" type="String">The user's email, when available.</ResponseField>
    <ResponseField name="role" type="WorkspaceRole!">Their role: `admin`, `l1`, `l2`, or `l3`.</ResponseField>
    <ResponseField name="kind" type="UserKind">Account kind: `user`, `backoffice_user`, `assistant`, or `api`.</ResponseField>
    <ResponseField name="createdAt" type="Date">When they joined the workspace.</ResponseField>
    <ResponseField name="invitedByName" type="String">Name of the user who invited them, if applicable.</ResponseField>
    <ResponseField name="invitedByEmail" type="String">Email of the user who invited them, if applicable.</ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="tasks" type="[Task!]!">
  Background tasks for this client (binder ingestion, tax prep, and so on). See the
  [tasks API](/apis/tasks). Narrow with the `type`, `status`, `triggeredBy`, and
  `limit` arguments.
</ResponseField>

The `Client` type exposes more fields (binder, documents, conversations, and
others) than are listed here. This page covers the fields needed to create,
list, fetch, and add documents to clients.

## Create a client

`createClient` creates a client and, optionally, kicks off binder ingestion for
any documents you have already staged (see [Uploading
documents](/guides/uploading-documents)).

```graphql theme={null}
mutation CreateClient($input: CreateClientInput!) {
  createClient(input: $input) {
    client {
      id
      name
      externalId
      status
      returnType
      taxYear
    }
    taskId
  }
}
```

### Input: `CreateClientInput`

```graphql theme={null}
input CreateClientInput {
  name: String!
  externalId: String!
  returnType: ReturnType!
  taxYear: Int!
  uploadIds: [String!]
}
```

<ParamField path="name" type="String!" required>
  The client's display name.
</ParamField>

<ParamField path="externalId" type="String!" required>
  Your identifier for the client. Must be unique within the workspace.
</ParamField>

<ParamField path="returnType" type="ReturnType!" required>
  One of `F1040`, `F1041`, `F1065`, `F1120`, `F1120S`, `F990`.
</ParamField>

<ParamField path="taxYear" type="Int!" required>
  The tax year, for example `2025`.
</ParamField>

<ParamField path="uploadIds" type="[String!]">
  Optional. Upload IDs from the [upload endpoint](/guides/uploading-documents). If
  provided, Filed ingests these documents into the new client's binder and returns
  a `taskId` you can track.
</ParamField>

### Returns: `CreateClientResult`

```graphql theme={null}
type CreateClientResult {
  client: Client!
  taskId: ID
}
```

<ResponseField name="client" type="Client!">
  The created client.
</ResponseField>

<ResponseField name="taskId" type="ID">
  The binder ingestion [task](/apis/tasks) ID, present only when `uploadIds` were
  supplied. `null` when the client was created without documents.
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation CreateClient($input: CreateClientInput!) { createClient(input: $input) { client { id name externalId status returnType taxYear } taskId } }",
      "variables": {
        "input": {
          "name": "Jane Taxpayer",
          "externalId": "PMS-10432",
          "returnType": "F1040",
          "taxYear": 2025,
          "uploadIds": ["018f9c2a-7b1e-7c3d-9a4e-2f6b1c8d0e5a"]
        }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "createClient": {
        "client": {
          "id": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
          "name": "Jane Taxpayer",
          "externalId": "PMS-10432",
          "status": "active",
          "returnType": "F1040",
          "taxYear": 2025
        },
        "taskId": "018f9c2b-1a2b-7c3d-8e4f-5a6b7c8d9e0f"
      }
    }
  }
  ```
</ResponseExample>

## List clients

Read `workspace.clients` to list clients. Filter, page, and sort with the
arguments below.

```graphql theme={null}
query ListClients($filters: ClientFilters, $offset: Int, $limit: Int, $sortBy: SortBy) {
  me {
    ... on WorkspaceUser {
      workspace {
        clients(filters: $filters, offset: $offset, limit: $limit, sortBy: $sortBy) {
          id
          name
          externalId
          status
          returnType
          taxYear
          createdAt
        }
      }
    }
  }
}
```

### Arguments

```graphql theme={null}
input ClientFilters {
  ids: [ID!]
  status: [ClientStatus!]
  search: String
  assigneeIds: [ID!]
  assignedToMe: Boolean
}

input SortBy {
  field: String!
  order: SortByOrder!   # ASC | DESC
}
```

<ParamField path="filters.ids" type="[ID!]">
  Return only clients with these IDs. This is how you [fetch a single
  client](#fetch-a-single-client).
</ParamField>

<ParamField path="filters.status" type="[ClientStatus!]">
  Return only clients in these statuses (`active`, `archived`).
</ParamField>

<ParamField path="filters.search" type="String">
  Free-text search over client name and external ID.
</ParamField>

<ParamField path="filters.assigneeIds" type="[ID!]">
  Return only clients assigned to these workspace users.
</ParamField>

<ParamField path="filters.assignedToMe" type="Boolean">
  When `true`, return only clients assigned to the authenticated user.
</ParamField>

<ParamField path="offset" type="Int">
  Number of clients to skip, for pagination.
</ParamField>

<ParamField path="limit" type="Int">
  Maximum number of clients to return.
</ParamField>

<ParamField path="sortBy" type="SortBy">
  Sort order, for example `{ "field": "createdAt", "order": "DESC" }`.
</ParamField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "query ListClients($filters: ClientFilters, $limit: Int, $sortBy: SortBy) { me { ... on WorkspaceUser { workspace { clients(filters: $filters, limit: $limit, sortBy: $sortBy) { id name externalId status returnType taxYear createdAt } } } } }",
      "variables": {
        "filters": { "status": ["active"], "search": "jane" },
        "limit": 20,
        "sortBy": { "field": "createdAt", "order": "DESC" }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "me": {
        "workspace": {
          "clients": [
            {
              "id": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
              "name": "Jane Taxpayer",
              "externalId": "PMS-10432",
              "status": "active",
              "returnType": "F1040",
              "taxYear": 2025,
              "createdAt": "2026-07-01T15:04:22.000Z"
            }
          ]
        }
      }
    }
  }
  ```
</ResponseExample>

## Fetch a single client

There is no `client(id:)` query. Fetch one client by passing its ID in
`filters.ids` and reading the first element.

```graphql theme={null}
query GetClient($clientId: ID!) {
  me {
    ... on WorkspaceUser {
      workspace {
        clients(filters: { ids: [$clientId] }) {
          id
          name
          externalId
          status
          returnType
          taxYear
          createdAt
          assignees {
            id
            name
            email
            role
          }
        }
      }
    }
  }
}
```

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "query GetClient($clientId: ID!) { me { ... on WorkspaceUser { workspace { clients(filters: { ids: [$clientId] }) { id name externalId status returnType taxYear createdAt assignees { id name email role } } } } } }",
      "variables": { "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c" }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "me": {
        "workspace": {
          "clients": [
            {
              "id": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
              "name": "Jane Taxpayer",
              "externalId": "PMS-10432",
              "status": "active",
              "returnType": "F1040",
              "taxYear": 2025,
              "createdAt": "2026-07-01T15:04:22.000Z",
              "assignees": [
                {
                  "id": "019f0fb6-37b1-7800-b7bc-0d11288504b1",
                  "name": "Jane Preparer",
                  "email": "jane@example-firm.com",
                  "role": "admin"
                }
              ]
            }
          ]
        }
      }
    }
  }
  ```
</ResponseExample>

<Note>
  An empty `clients` array means no client with that ID exists in this workspace.
  Handle it as a not-found result.
</Note>

## Add documents to a client

`addClientDocuments` attaches already-staged uploads to an existing client and
ingests them into the client's binder. Stage the files first with the [upload
endpoint](/guides/uploading-documents).

```graphql theme={null}
mutation AddClientDocuments($input: AddClientDocumentsInput!) {
  addClientDocuments(input: $input) {
    taskId
  }
}
```

### Input: `AddClientDocumentsInput`

```graphql theme={null}
input AddClientDocumentsInput {
  clientId: ID!
  uploadIds: [String!]!
}
```

<ParamField path="clientId" type="ID!" required>
  The client to add documents to.
</ParamField>

<ParamField path="uploadIds" type="[String!]!" required>
  One or more upload IDs from the [upload
  endpoint](/guides/uploading-documents).
</ParamField>

### Returns: `AddClientDocumentsResult`

```graphql theme={null}
type AddClientDocumentsResult {
  taskId: ID
}
```

<ResponseField name="taskId" type="ID">
  The binder ingestion [task](/apis/tasks) ID. Poll it until `status` is
  `COMPLETED` to know the documents are filed in the binder.
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation AddClientDocuments($input: AddClientDocumentsInput!) { addClientDocuments(input: $input) { taskId } }",
      "variables": {
        "input": {
          "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
          "uploadIds": ["018f9c2a-7b1e-7c3d-9a4e-2f6b1c8d0e5a"]
        }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
      "data": {
      "addClientDocuments": {
        "taskId": "018f9c2b-1a2b-7c3d-8e4f-5a6b7c8d9e0f"
      }
    }
  }
  ```
</ResponseExample>

## Manage clients

Beyond create, list, and fetch, the API exposes a set of mutations for the rest
of the client lifecycle: rename, archive, restore, permanently delete, and
assign or unassign workspace users. All of them take a single `input` argument
identified by `clientId`, return either the updated [`Client`](#the-client-type)
or a `Boolean`, and require a **`workspaceToken`** (see
[Authentication](/guides/authentication)).

### Update a client

`updateClient` renames a client. Only the `name` is mutable through this
mutation.

```graphql theme={null}
mutation UpdateClient($input: UpdateClientInput!) {
  updateClient(input: $input) {
    id
    name
    externalId
    status
    returnType
    taxYear
  }
}
```

### Input: `UpdateClientInput`

```graphql theme={null}
input UpdateClientInput {
  clientId: ID!
  name: String!
}
```

<ParamField path="clientId" type="ID!" required>
  The ID of the client to rename.
</ParamField>

<ParamField path="name" type="String!" required>
  The new display name for the client.
</ParamField>

### Returns: `Client!`

The updated [`Client`](#the-client-type).

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation UpdateClient($input: UpdateClientInput!) { updateClient(input: $input) { id name externalId status returnType taxYear } }",
      "variables": {
        "input": {
          "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
          "name": "Jane Q. Taxpayer"
        }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "updateClient": {
        "id": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
        "name": "Jane Q. Taxpayer",
        "externalId": "PMS-10432",
        "status": "active",
        "returnType": "F1040",
        "taxYear": 2025
      }
    }
  }
  ```
</ResponseExample>

### Archive a client

`archiveClient` sets the client's `status` to `archived`. Archived clients are
excluded from default lists but kept on disk and can be restored.

```graphql theme={null}
mutation ArchiveClient($input: ArchiveClientInput!) {
  archiveClient(input: $input) {
    id
    name
    status
  }
}
```

### Input: `ArchiveClientInput`

```graphql theme={null}
input ArchiveClientInput {
  clientId: ID!
}
```

<ParamField path="clientId" type="ID!" required>
  The ID of the client to archive.
</ParamField>

### Returns: `Client!`

The archived [`Client`](#the-client-type) with `status` set to `archived`.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation ArchiveClient($input: ArchiveClientInput!) { archiveClient(input: $input) { id name status } }",
      "variables": {
        "input": { "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c" }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "archiveClient": {
        "id": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
        "name": "Jane Q. Taxpayer",
        "status": "archived"
      }
    }
  }
  ```
</ResponseExample>

### Restore a client

`restoreClient` sets an archived client's `status` back to `active`.

```graphql theme={null}
mutation RestoreClient($input: RestoreClientInput!) {
  restoreClient(input: $input) {
    id
    name
    status
  }
}
```

### Input: `RestoreClientInput`

```graphql theme={null}
input RestoreClientInput {
  clientId: ID!
}
```

<ParamField path="clientId" type="ID!" required>
  The ID of the archived client to restore.
</ParamField>

### Returns: `Client!`

The restored [`Client`](#the-client-type) with `status` set to `active`.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation RestoreClient($input: RestoreClientInput!) { restoreClient(input: $input) { id name status } }",
      "variables": {
        "input": { "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c" }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "restoreClient": {
        "id": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
        "name": "Jane Q. Taxpayer",
        "status": "active"
      }
    }
  }
  ```
</ResponseExample>

### Delete a client

`deleteClient` permanently removes a client and its binder. It cannot be undone.

<Warning>
  `deleteClient` is irreversible. The client, its documents, and its binder are
  permanently removed. Prefer [`archiveClient`](#archive-a-client) when you only
  need to hide a client from active lists.
</Warning>

```graphql theme={null}
mutation DeleteClient($input: DeleteClientInput!) {
  deleteClient(input: $input)
}
```

### Input: `DeleteClientInput`

```graphql theme={null}
input DeleteClientInput {
  clientId: ID!
}
```

<ParamField path="clientId" type="ID!" required>
  The ID of the client to permanently delete.
</ParamField>

### Returns: `Boolean!`

`true` when the client was deleted.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation DeleteClient($input: DeleteClientInput!) { deleteClient(input: $input) }",
      "variables": {
        "input": { "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c" }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "deleteClient": true
    }
  }
  ```
</ResponseExample>

### Assign a user to a client

`assignUserToClient` assigns a workspace user to a client and returns the
created `ClientAssignee`.

```graphql theme={null}
mutation AssignUserToClient($input: AssignUserToClientInput!) {
  assignUserToClient(input: $input) {
    id
    clientId
    user {
      id
      userId
      name
      email
      role
    }
    assignedBy {
      id
      userId
      name
      email
      role
    }
    createdAt
  }
}
```

### Input: `AssignUserToClientInput`

```graphql theme={null}
input AssignUserToClientInput {
  clientId: ID!
  userId: ID!
}
```

<ParamField path="clientId" type="ID!" required>
  The ID of the client to assign the user to.
</ParamField>

<ParamField path="userId" type="ID!" required>
  The ID of the workspace user to assign. Use the `userId` of a
  `WorkspaceUserShortDetails` from the workspace's members, or the `id` returned
  by [`me`](/apis/me).
</ParamField>

### Returns: `ClientAssignee!`

```graphql theme={null}
type ClientAssignee {
  id: ID!
  clientId: ID!
  user: WorkspaceUserShortDetails!
  assignedBy: WorkspaceUserShortDetails!
  createdAt: Date!
}
```

<ResponseField name="id" type="ID!">
  The assignment record ID.
</ResponseField>

<ResponseField name="clientId" type="ID!">
  The client the user was assigned to.
</ResponseField>

<ResponseField name="user" type="WorkspaceUserShortDetails!">
  The workspace user who was assigned. See `WorkspaceUserShortDetails` under
  [`assignees`](#the-client-type) for the field shape.
</ResponseField>

<ResponseField name="assignedBy" type="WorkspaceUserShortDetails!">
  The workspace user who performed the assignment (the authenticated caller).
</ResponseField>

<ResponseField name="createdAt" type="Date!">
  When the assignment was created.
</ResponseField>

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation AssignUserToClient($input: AssignUserToClientInput!) { assignUserToClient(input: $input) { id clientId user { id userId name email role } assignedBy { id userId name email role } createdAt } }",
      "variables": {
        "input": {
          "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
          "userId": "019f0fb6-37b1-7800-b7bc-0d11288504b1"
        }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "assignUserToClient": {
        "id": "019f0fb6-4a2c-7900-9c01-2b3c4d5e6f70",
        "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
        "user": {
          "id": "019f0fb6-37b1-7800-b7bc-0d11288504b1",
          "userId": "019f0fb6-3001-7900-b7bc-0d11288504b1",
          "name": "Jane Preparer",
          "email": "jane@example-firm.com",
          "role": "admin"
        },
        "assignedBy": {
          "id": "019f0fb6-37b1-7800-b7bc-0d11288504b1",
          "userId": "019f0fb6-3001-7900-b7bc-0d11288504b1",
          "name": "Jane Preparer",
          "email": "jane@example-firm.com",
          "role": "admin"
        },
        "createdAt": "2026-07-04T18:22:01.000Z"
      }
    }
  }
  ```
</ResponseExample>

### Unassign a user from a client

`unassignUserFromClient` removes a workspace user's assignment from a client.

```graphql theme={null}
mutation UnassignUserFromClient($input: UnassignUserFromClientInput!) {
  unassignUserFromClient(input: $input)
}
```

### Input: `UnassignUserFromClientInput`

```graphql theme={null}
input UnassignUserFromClientInput {
  clientId: ID!
  userId: ID!
}
```

<ParamField path="clientId" type="ID!" required>
  The ID of the client to remove the assignment from.
</ParamField>

<ParamField path="userId" type="ID!" required>
  The ID of the workspace user to unassign.
</ParamField>

### Returns: `Boolean!`

`true` when the assignment was removed.

<RequestExample>
  ```bash cURL theme={null}
  curl -X POST https://router.apps.filed.com/graphql \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_WORKSPACE_TOKEN" \
    -d '{
      "query": "mutation UnassignUserFromClient($input: UnassignUserFromClientInput!) { unassignUserFromClient(input: $input) }",
      "variables": {
        "input": {
          "clientId": "018f9c2a-3d5f-7a10-b2c4-9e8d7f6a5b4c",
          "userId": "019f0fb6-37b1-7800-b7bc-0d11288504b1"
        }
      }
    }'
  ```
</RequestExample>

<ResponseExample>
  ```json theme={null}
  {
    "data": {
      "unassignUserFromClient": true
    }
  }
  ```
</ResponseExample>