# Invite Someone from Your Event Team to Join Your Workspace

> Invite a colleague as an Admin, Team Member or Guest, choose what they can see and do, and re-send the invitation if it gets lost.

This is the Markdown copy of https://api.exhibitday.com/Help/V1?guide=invite-team-member 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

Invite a colleague as an Admin, Team Member or Guest, choose what they can see and do, and re-send the invitation if it gets lost.

Example use case

A new coordinator joins your trade show team on Monday. Your onboarding tool invites them to ExhibitDay as a Team Member with the usual Team Member access, except Event Logs and the Workspace Activity Feed.

What you'll end up with

An open invitation for one email address, with the role, permissions and content restrictions you chose, and its invitation ID.

Before you start

Have a workspace API key and the person's work email address. Decide whether they should be an Admin, a Team Member or a Guest.

Good to know

The invitation email goes out as soon as the invitation is saved. The person joins your workspace only after they accept it and sign in or create an ExhibitDay account.

## At a glance

Time to try

About 10 minutes

Effect on your data

Creates records

Endpoints

6

The example creates one workspace invitation and emails it right away. Re-sending sends another email. The other requests only read.

- [`GET /v1/workspace_settings/users`](https://api.exhibitday.com/Help/V1?epf=6&amp;topic=users#get-v1-workspace_settings-users)
- [`GET /v1/workspace_settings/users/invitations`](https://api.exhibitday.com/Help/V1?epf=6&amp;topic=user-invitations#get-v1-workspace_settings-users-invitations)
- [`GET /v1/references/permissions_and_content_restrictions`](https://api.exhibitday.com/Help/V1?epf=3#get-v1-references-permissions_and_content_restrictions)
- [`POST /v1/workspace_settings/users/invitations`](https://api.exhibitday.com/Help/V1?epf=6&amp;topic=user-invitations#post-v1-workspace_settings-users-invitations)
- [`POST /v1/workspace_settings/users/invitations/resend`](https://api.exhibitday.com/Help/V1?epf=6&amp;topic=user-invitations#post-v1-workspace_settings-users-invitations-resend)
- [`GET /v1/workspace_settings/users/invitations/info`](https://api.exhibitday.com/Help/V1?epf=6&amp;topic=user-invitations#get-v1-workspace_settings-users-invitations-info)

## How it works

1. Check Users & Permissions and the open invitations for the email address.
2. For a Team Member or Guest, check your permission choices against the workspace's list.
3. Create the invitation with one `Idempotency-Key`, then read it back.

## Roles, permissions and content restrictions

Everyone you invite gets one of three roles. They are the same choices as Invite a User under Workspace Settings > Users & Permissions.

| Role | `workspace_role_id` | What it means on the website |
| --- | --- | --- |
| Admin | `1` | Admin / Full Access. Every permission and no content restrictions. |
| Team Member | `2` | Signs in and works in your workspace. You choose which areas they can view and change. |
| Guest | `3` | Guest (read-only). Signs in to view the areas you allow. A Guest can't be given permissions to change things. |

- Permissions turn on or off what a Team Member or Guest can see and do. On the website they're grouped as Event Management (General, Booth, Staff / Attendees, Travel, Asset Reservations, Giveaways, Shipments, Sponsorships, Misc. Event-Specific Expenses & Credits, Playbook, Tasks and your Special tab), Event History/Logs and Workspace Activity, AI Assistant (Planna), Asset Management Area, Budgets, ROI, Objectives & ROO, and Workspace Management. Examples: “Has access to view event Booth tab” and “Can add/update/delete tasks assigned only to self (this user)”.
- Content Restrictions limit which records a Team Member or Guest sees, even in areas they can open.

| Content Restriction (as the website shows it) | Send in `content_restrictions` |
| --- | --- |
| User can only access his/her Events (Events they created or are tagged in, for example as an attendee or a Task's Assignee) | `only_my_events` |
| User can only see Travel Reservations that the user either created, or is tagged in | `only_my_travel` |
| User can only see Playbook items that the user either created, or is tagged in | `only_my_playbook` |
| Only sees user's own activity in the Activity Feed | `only_my_activity` |
| Hide summary details for related items this user can't view | `only_accessible_related_items` |

- The API sends permissions as the ones to deny. Leave `permission_denial_ids` out to give the role its usual defaults. Send `[]` to deny nothing the role can choose. A list denies exactly the permissions in it, so include the role's default denials you want to keep. Each permission's `default` in Step 3 shows them.
- Your workspace's list of permissions, with each role's default, comes from `GET /v1/references/permissions_and_content_restrictions`. A permission your workspace doesn't use isn't listed.
- Some choices depend on others, as on the website. Denying a permission also denies the permissions that need it. `only_my_events`, `only_my_travel` and `only_my_playbook` also turn on `only_my_activity`. When this changes your request, the invitation is still created and the `X-API-Warnings` response header lists each change.

## Resources

A Resource is a non-user, such as a speaker, a contractor or temp staff. You add Resources on the website with Add a Resource (non-user) under Users & Permissions. Resources can't sign in, and you can't create them through the API. `GET /v1/workspace_settings/users` with `filter_by_is_resource=true` lists them. Tasks can't be assigned to Resources. To give a Resource access, invite their email address as a user. The website can then merge the Resource with the new user.

## Check, invite and confirm

## Step 1: Check whether they're in Users & Permissions

Look up the whole email address among the workspace's users and Resources.

```bash
curl -X GET "https://api.exhibitday.com/v1/workspace_settings/users?filter_by_email=jordan%40example.org" -H "Authorization: Bearer YOUR_API_KEY"
```

**Check:** An empty `list_data` means no active user or Resource has this email. If a row comes back with `is_resource` true, the person is a Resource. Invite them only if they now need to sign in.

## Step 2: Check for an open invitation

Make sure nobody has invited this address yet.

```bash
curl -X GET "https://api.exhibitday.com/v1/workspace_settings/users/invitations?filter_by_email=jordan%40example.org" -H "Authorization: Bearer YOUR_API_KEY"
```

**Check:** If a row comes back, keep its `id` and see Step 5 instead of inviting again. `status` is `Pending` until the person accepts, then `Accepted, not yet joined` until they join.

## Step 3: Choose permissions and content restrictions

For a Team Member or Guest, read the choices your workspace offers. Skip this step for an Admin.

```bash
curl -X GET "https://api.exhibitday.com/v1/references/permissions_and_content_restrictions" -H "Authorization: Bearer YOUR_API_KEY"
```

**Example response (shortened)**

```json
{
  "list_data": [
    {
      "type": "permission",
      "permission_id": 8,
      "name": "Can update event booth information (under the event Booth tab)",
      "roles": [
        {
          "workspace_role_id": 2,
          "workspace_role": "Team Member",
          "can_be_set": true,
          "default": "allowed"
        },
        {
          "workspace_role_id": 3,
          "workspace_role": "Guest",
          "can_be_set": false,
          "default": "denied"
        }
      ]
    },
    {
      "type": "permission",
      "permission_id": 11,
      "name": "Can add/update/delete tasks assigned only to self (this user)",
      "roles": [
        {
          "workspace_role_id": 2,
          "workspace_role": "Team Member",
          "can_be_set": true,
          "default": "allowed"
        },
        {
          "workspace_role_id": 3,
          "workspace_role": "Guest",
          "can_be_set": false,
          "default": "denied"
        }
      ]
    }
  ]
}
```

**Check:** Use `permission_id` values in `permission_denial_ids` and `content_restriction` names in `content_restrictions`. Choose only rows where `can_be_set` is true for your role.

## Step 4: Send the invitation

Send the email address and role. Add the header `Idempotency-Key: YOUR_UNIQUE_KEY` so a retry can reuse the original result. This example invites a Team Member, keeps the role's default denials (`1`, `2`, `3`, `12`, `19`, `31` and `32`) and also denies `35`, Event Logs and the Workspace Activity Feed.

```bash
curl -X POST "https://api.exhibitday.com/v1/workspace_settings/users/invitations" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"email\":\"jordan@example.org\",\"workspace_role_id\":2,\"permission_denial_ids\":[1,2,3,12,19,31,32,35]}"
```

**Example response (shortened)**

```json
{
  "id": 12345,
  "email": "jordan@example.org",
  "status": "Pending",
  "workspace_role_id": 2,
  "workspace_role": "Team Member",
  "permission_denials": [
    {
      "id": 1,
      "name": "Illustrative permission definition"
    },
    {
      "id": 2,
      "name": "Illustrative permission definition"
    },
    {
      "id": 3,
      "name": "Illustrative permission definition"
    },
    {
      "id": 12,
      "name": "Illustrative permission definition"
    },
    {
      "id": 19,
      "name": "Illustrative permission definition"
    },
    {
      "id": 31,
      "name": "Illustrative permission definition"
    },
    {
      "id": 32,
      "name": "Illustrative permission definition"
    },
    {
      "id": 35,
      "name": "Illustrative permission definition"
    }
  ],
  "send_invitation_email": true,
  "record_revision": "r1:H63G2_yEc-scqWFhq647LFYlVxTpapbwQoK6irVnddM"
}
```

Other ways to invite:

| To invite | Send |
| --- | --- |
| An Admin | `workspace_role_id=1`, with no `permission_denial_ids` or `content_restrictions` |
| A Team Member with the role's defaults | `workspace_role_id=2`, and leave out `permission_denial_ids` |
| A Guest who sees only their own Travel Reservations | `workspace_role_id=3` and `content_restrictions` with `only_my_travel` and `only_my_activity` set to true |
| Someone you'll email later | Add `send_invitation_email=false`. The invitation waits until you re-send it. |

**Check:** Save the invitation `id`. Compare `permission_denials` and `content_restrictions` in the full response with what you meant to send, and read the `X-API-Warnings` header for any changes ExhibitDay made.

## Step 5: Re-send an invitation that got lost

Email an open invitation again, the same way Re-send Invitation works on the website. To re-send only if nothing changed, add `expected_revision` with the `record_revision` from Step 6.

```bash
curl -X POST "https://api.exhibitday.com/v1/workspace_settings/users/invitations/resend" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"id\":12345}"
```

**Check:** Each successful request sends another email, so don't retry blindly. Leave out `Idempotency-Key`. This request refuses it. If you get `record_changed` (HTTP 409), read the invitation again before deciding whether to re-send.

## Step 6: Confirm what was saved

Read the invitation by ID to see its saved role, permissions and content restrictions.

```bash
curl -X GET "https://api.exhibitday.com/v1/workspace_settings/users/invitations/info?id=12345&%24include_record_revision=true" -H "Authorization: Bearer YOUR_API_KEY"
```

**Check:** Confirm the email, role and access match your intent. Keep `record_revision` if you plan to re-send or revoke the invitation later.

## 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. |
| `email` | The email address of the person to invite. The example uses `jordan@example.org`. Use your own test address. |
| `workspace_role_id` | `1` Admin, `2` Team Member or `3` Guest. The example invites a Team Member. |
| `permission_denial_ids` | The permission IDs to deny, from Step 3. The example sends the Team Member default denials plus `35` (Event Logs and the Workspace Activity Feed). Leave it out for the role's defaults. |

**Careful.** This example creates an invitation and emails it to a real address. Use your own test address, then revoke the invitation in Users & Permissions or with `DELETE /v1/workspace_settings/users/invitations`.

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 POST "https://api.exhibitday.com/v1/workspace_settings/users/invitations" -H "Authorization: Bearer YOUR_API_KEY" -H "Content-Type: application/json" -d "{\"email\":\"jordan@example.org\",\"workspace_role_id\":2,\"permission_denial_ids\":[1,2,3,12,19,31,32,35]}"
```

```javascript
const response = await fetch("https://api.exhibitday.com/v1/workspace_settings/users/invitations", {
  method: "POST",
  headers: { "Authorization": "Bearer YOUR_API_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({ "email": "jordan@example.org", "workspace_role_id": 2, "permission_denial_ids": [1,2,3,12,19,31,32,35] })
});
const data = await response.json();
console.log(response.status, data);
```

```python
import requests
import json

response = requests.post(
    "https://api.exhibitday.com/v1/workspace_settings/users/invitations",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"email": "jordan@example.org", "workspace_role_id": 2, "permission_denial_ids": json.loads("[1,2,3,12,19,31,32,35]")},
)
print(response.status_code, response.json())
```

```csharp
using System;
using System.Text.Json;
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.PostAsync("https://api.exhibitday.com/v1/workspace_settings/users/invitations",
    JsonContent.Create(new { email = "jordan@example.org", workspace_role_id = 2, permission_denial_ids = JsonDocument.Parse("[1,2,3,12,19,31,32,35]").RootElement.Clone() }));
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/workspace_settings/users/invitations"))
            .header("Authorization", "Bearer YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .method("POST", HttpRequest.BodyPublishers.ofString("{\"email\":\"jordan@example.org\",\"workspace_role_id\":2,\"permission_denial_ids\":[1,2,3,12,19,31,32,35]}"))
            .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/workspace_settings/users/invitations');
curl_setopt_array($curl, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer YOUR_API_KEY', 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS => '{"email":"jordan@example.org","workspace_role_id":2,"permission_denial_ids":[1,2,3,12,19,31,32,35]}',
]);
$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/workspace_settings/users/invitations')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = '{"email":"jordan@example.org","workspace_role_id":2,"permission_denial_ids":[1,2,3,12,19,31,32,35]}'
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("POST", "https://api.exhibitday.com/v1/workspace_settings/users/invitations", strings.NewReader("{\"email\":\"jordan@example.org\",\"workspace_role_id\":2,\"permission_denial_ids\":[1,2,3,12,19,31,32,35]}"))
    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 409 — Conflict 429 — Too Many Requests 500 — Internal Server Error

Example Successful request

```json
{
  "id": 12345,
  "email": "jordan@example.org",
  "status_id": 1,
  "status": "Pending",
  "workspace_role_id": 2,
  "workspace_role": "Team Member",
  "invited_by": {
    "id": null,
    "first_name": "ExhibitDay",
    "last_name": "API",
    "display_name": "ExhibitDay API",
    "email": null,
    "type": null,
    "workspace_role": null,
    "is_active": true
  },
  "invitation_created_timestamp": "2030-01-15T12:00:00",
  "invitation_accepted_timestamp": null,
  "permission_denials": [
    {
      "id": 1,
      "name": "Illustrative permission definition"
    },
    {
      "id": 2,
      "name": "Illustrative permission definition"
    },
    {
      "id": 3,
      "name": "Illustrative permission definition"
    },
    {
      "id": 12,
      "name": "Illustrative permission definition"
    },
    {
      "id": 19,
      "name": "Illustrative permission definition"
    },
    {
      "id": 31,
      "name": "Illustrative permission definition"
    },
    {
      "id": 32,
      "name": "Illustrative permission definition"
    },
    {
      "id": 35,
      "name": "Illustrative permission definition"
    }
  ],
  "content_restrictions": {
    "only_my_events": false,
    "only_my_travel": false,
    "only_my_playbook": false,
    "only_my_activity": false,
    "only_accessible_related_items": false
  },
  "send_invitation_email": true,
  "record_revision": "r1:H63G2_yEc-scqWFhq647LFYlVxTpapbwQoK6irVnddM"
}
```

Note: POST /v1/workspace_settings/users/invitations - HTTP 200. The new invitation for a Team Member, with the permissions it denies. Keep the returned id to re-send or check the invitation.

```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": "This Idempotency-Key was already used with a different request. Use a new key for a new request.",
  "error_code": "idempotency_key_reused",
  "errors": [
    "This Idempotency-Key was already used with a different request. Use a new key for a new request."
  ],
  "error_params": [
    "Idempotency-Key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The email parameter in the JSON body is missing. Send the email address of the person to invite.",
  "error_code": "invalid_request",
  "errors": [
    "The email parameter in the JSON body is missing. Send the email address of the person to invite."
  ],
  "error_params": [
    "email"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The email parameter in the JSON body is not a valid email address. Send one address of up to 254 characters.",
  "error_code": "invalid_request",
  "errors": [
    "The email parameter in the JSON body is not a valid email address. Send one address of up to 254 characters."
  ],
  "error_params": [
    "email"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The workspace_role_id parameter in the JSON body is not valid. Allowed values: 1 (Admin) | 2 (Team Member) | 3 (Guest).",
  "error_code": "invalid_request",
  "errors": [
    "The workspace_role_id parameter in the JSON body is not valid. Allowed values: 1 (Admin) | 2 (Team Member) | 3 (Guest)."
  ],
  "error_params": [
    "workspace_role_id"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "This workspace has no available user or invitation slots for this role.",
  "error_code": "invalid_request",
  "errors": [
    "This workspace has no available user or invitation slots for this role."
  ],
  "error_params": [
    "workspace_role_id"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "This workspace has no available Admin invitation slots.",
  "error_code": "invalid_request",
  "errors": [
    "This workspace has no available Admin invitation slots."
  ],
  "error_params": [
    "workspace_role_id"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The email parameter in the JSON body belongs to an active member of this workspace.",
  "error_code": "invalid_request",
  "errors": [
    "The email parameter in the JSON body belongs to an active member of this workspace."
  ],
  "error_params": [
    "email"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "An open invitation already exists for the email parameter in the JSON body. Find it with GET /v1/workspace_settings/users/invitations, or revoke it before inviting again.",
  "error_code": "invalid_request",
  "errors": [
    "An open invitation already exists for the email parameter in the JSON body. Find it with GET /v1/workspace_settings/users/invitations, or revoke it before inviting again."
  ],
  "error_params": [
    "email"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The email parameter in the JSON body is not an allowed email address. To control spam, ExhibitDay doesn't allow accounts with that email address or from that email provider. Use another email address.",
  "error_code": "invalid_request",
  "errors": [
    "The email parameter in the JSON body is not an allowed email address. To control spam, ExhibitDay doesn't allow accounts with that email address or from that email provider. Use another email address."
  ],
  "error_params": [
    "email"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The email parameter in the JSON body uses an email domain this workspace doesn't send invitations to. Allowed domains: northwind.example.",
  "error_code": "invalid_request",
  "errors": [
    "The email parameter in the JSON body uses an email domain this workspace doesn't send invitations to. Allowed domains: northwind.example."
  ],
  "error_params": [
    "email"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The workspace_role_id parameter in the JSON body is not valid for this invitation. This plan supports Admin invitations only.",
  "error_code": "invalid_request",
  "errors": [
    "The workspace_role_id parameter in the JSON body is not valid for this invitation. This plan supports Admin invitations only."
  ],
  "error_params": [
    "workspace_role_id"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 400,
  "status": "Bad Request",
  "message": "The content_restrictions parameter in the JSON body is not valid for this invitation. Content restrictions require access to their corresponding Travel or Playbook area.",
  "error_code": "invalid_request",
  "errors": [
    "The content_restrictions parameter in the JSON body is not valid for this invitation. Content restrictions require access to their corresponding Travel or Playbook area."
  ],
  "error_params": [
    "content_restrictions"
  ],
  "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": 401,
  "status": "Unauthorized",
  "message": "The API key is not valid for this request. Send your current key in the Authorization header as 'Bearer YOUR_API_KEY'.",
  "error_code": "invalid_api_key",
  "errors": [
    "The API key is not valid for this request. Send your current key in the Authorization header as 'Bearer YOUR_API_KEY'."
  ],
  "error_params": [
    "api_key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 409,
  "status": "Conflict",
  "message": "A request with this Idempotency-Key is still being processed. Retry after a moment.",
  "error_code": "idempotency_key_in_use",
  "errors": [
    "A request with this Idempotency-Key is still being processed. Retry after a moment."
  ],
  "error_params": [
    "Idempotency-Key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 409,
  "status": "Conflict",
  "message": "A previous request with this Idempotency-Key did not finish and its outcome is unknown, so this retry was not run to avoid creating a duplicate. Check whether the earlier request succeeded; to try again, use a new Idempotency-Key.",
  "error_code": "idempotency_key_indeterminate",
  "errors": [
    "A previous request with this Idempotency-Key did not finish and its outcome is unknown, so this retry was not run to avoid creating a duplicate. Check whether the earlier request succeeded; to try again, use a new Idempotency-Key."
  ],
  "error_params": [
    "Idempotency-Key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 409,
  "status": "Conflict",
  "message": "The saved response cannot be replayed safely.",
  "error_code": "idempotency_key_indeterminate",
  "errors": [
    "The earlier request with this Idempotency-Key completed, but its saved response cannot be returned safely. This retry was not run and its key was not released. Look for the existing record with a GET; use a new Idempotency-Key only after checking whether another create is needed."
  ],
  "error_params": [
    "Idempotency-Key"
  ],
  "request_id": "0123456789abcdef0123456789abcdef"
}
```

```json
{
  "status_code": 409,
  "status": "Conflict",
  "message": "Invitation settings are busy or changed. Retrieve current invitations before deciding whether to retry.",
  "error_code": "record_changed",
  "errors": [
    "Invitation settings are busy or changed. Retrieve current invitations before deciding whether to retry."
  ],
  "error_params": [],
  "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": [
    "The save outcome could not be confirmed. Retrieve current invitations before retrying; this request was not automatically retried."
  ],
  "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"
}
```

```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 invites one email address per request. The website can invite several at once on some plans.
- Your plan decides who you can invite. A workspace on a plan with Admin invitations only refuses Team Member and Guest invitations. Plans also limit the number of users and Admins. A full workspace returns `invalid_request` (HTTP 400) and saves nothing.
- To control spam, ExhibitDay refuses some email addresses and email providers. The API then returns `invalid_request` (HTTP 400) and saves nothing. Use another address.
- Invitations created through the API send ExhibitDay's API invitation email, which doesn't name a person as the inviter. `invited_by` returns the ExhibitDay API.
- A successful response doesn't confirm the email was delivered. If the email couldn't be sent, the invitation is still saved and `X-API-Warnings` says so. Use Re-send.
- If you lose the response, retry the exact request with the same key. If you can't tell whether it worked, check for an open invitation (Step 2) before you invite again.
- Inviting someone doesn't change an existing user's permissions. Change those on the website in Users & Permissions.

## Related guides

- [Find Users and Resources by Name, Email or Role](https://api.exhibitday.com/Help/V1?guide=find-people)
- [Create Tasks from Forms, Tickets or Other Apps](https://api.exhibitday.com/Help/V1?guide=create-tasks)
- [Handle Errors and Retry Failed Requests](https://api.exhibitday.com/Help/V1?guide=errors-and-retries)
