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

# List invitations

GET https://api.natural.co/party-invitations

List invitations with optional filters by party, email, or status.

Reference: https://natural.ferndocs.com/api-reference/api-reference/invitations/list

## Authentication

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

## Request

### Query parameters

- `partyId` (string, optional)
- `email` (string, optional)
- `status` (enum, optional) — Filter by status
  - Allowed values: `PENDING`, `ACCEPTED`, `REVOKED`

### Headers

- `X-Agent-ID` (string, optional, nullable) — Agent ID (agt_xxx) identifying which agent is making the request.
- `X-Instance-ID` (string, optional, nullable) — Required when X-Agent-ID is present. Session or conversation ID for agent observability.

## Response

### 200

Successful Response

- `data` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaDataItems, required)
- `meta` (PartyInvitationsGetResponsesContentApplicationJsonSchemaMeta, required)

## Errors

### 400 Bad Request Error

Validation Error

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 401 Unauthorized Error

Unauthorized

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 403 Forbidden Error

Forbidden

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 404 Not Found Error

Not Found — returned when the resource does not exist, or when it exists but is not accessible to your account. The two cases are intentionally indistinguishable, so that resource IDs cannot be enumerated by probing.

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 409 Conflict Error

Conflict

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 422 Unprocessable Entity Error

Validation Error

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 428 Precondition Error

Precondition Required

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 429 Too Many Requests Error

Too Many Requests

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 500 Internal Server Error

Internal Server Error

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 501 Not Implemented Error

Not Implemented

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 502 Bad Gateway Error

Bad Gateway

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

### 503 Service Unavailable Error

Service Unavailable

- `errors` (list of PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems, required)

## Types

### PartyInvitationsGetResponsesContentApplicationJsonSchemaDataItems

- `type` (enum, required) — Resource type
  - Allowed values: `invitation`
- `id` (string, required) — Invitation ID (inv_xxx)
- `attributes` (PartyInvitationsGetResponsesContentApplicationJsonSchemaDataItemsAttributes, required) — Resource attributes

### PartyInvitationsGetResponsesContentApplicationJsonSchemaMeta

- `pagination` (PartyInvitationsGetResponsesContentApplicationJsonSchemaMetaPagination, required)

### PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItems

- `code` (string, required) — Stable lower-snake-case public error code
- `detail` (string, required) — Safe user-facing error detail
- `status` (string, required) — HTTP status code as a string
- `meta` (PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItemsMeta, required) — Error metadata. Public responses include supportId only by default.
- `source` (PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItemsSource, optional) — Location of the invalid request value

### PartyInvitationsGetResponsesContentApplicationJsonSchemaDataItemsAttributes

Resource attributes

- `email` (string, required) — Invitee email address
- `role` (enum, required) — Role assigned on acceptance
  - Allowed values: `OWNER`, `ADMIN`, `MEMBER`, `VIEWER`
- `status` (enum, required) — Invitation status
  - Allowed values: `PENDING`, `ACCEPTED`, `REVOKED`
- `expiresAt` (string, required) — When this invitation expires
- `createdAt` (string, required) — When this invitation was created
- `acceptedAt` (string, required, nullable) — When this invitation was accepted

### PartyInvitationsGetResponsesContentApplicationJsonSchemaMetaPagination

- `hasMore` (boolean, required)
- `nextCursor` (string, required, nullable)

### PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItemsMeta

Error metadata. Public responses include supportId only by default.

- `supportId` (string, required) — Request/support ID for troubleshooting

### PartyInvitationsGetResponsesContentApplicationJsonSchemaErrorsItemsSource

Location of the invalid request value

- `pointer` (string, optional)
- `parameter` (string, optional)
- `header` (string, optional)

## Examples

**Response**

```json
{
  "data": [
    {
      "type": "invitation",
      "id": "inv_019cd4a832f37c4b8a1d63e94b7c8d12",
      "attributes": {
        "email": "engineer@velocitylogistics.com",
        "role": "MEMBER",
        "status": "PENDING",
        "expiresAt": "2026-01-11T15:30:00Z",
        "createdAt": "2026-01-04T15:30:00Z",
        "acceptedAt": null
      }
    }
  ],
  "meta": {
    "pagination": {
      "hasMore": false,
      "nextCursor": null
    }
  }
}
```

**SDK Code**

```python Default
import requests

url = "https://api.natural.co/party-invitations"

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

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

print(response.json())
```

```javascript Default
const url = 'https://api.natural.co/party-invitations';
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 Default
package main

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

func main() {

	url := "https://api.natural.co/party-invitations"

	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 Default
require 'uri'
require 'net/http'

url = URI("https://api.natural.co/party-invitations")

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 Default
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.natural.co/party-invitations")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.natural.co/party-invitations', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Default
using RestSharp;

var client = new RestClient("https://api.natural.co/party-invitations");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Default
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.natural.co/party-invitations")! 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()
```