# retrieveInvitations

Retrieve incoming connection, company-follow, and newsletter-subscription invitations.

This method retrieves all incoming invitations from the invitation manager.

```typescript
try {
  const workflow = await linkedapi.retrieveInvitations.execute();

  const { data, errors } = await linkedapi.retrieveInvitations.result(
    workflow.workflowId,
  );

  // The list of possible execution errors is below
  if (errors && errors.length > 0) {
    console.warn("Workflow completed with execution errors:");
    for (const error of errors) {
      console.warn(` - Type: ${error.type}, Message: ${error.message}`);
    }
  }

  // The structure of the 'data' object is below
  if (data) {
    console.log("Incoming invitations count:", data.length);
    for (const invitation of data) {
      console.log(`${invitation.invitationType}: ${invitation.name}`);
      if (invitation.invitationType === "connect") {
        console.log(invitation.publicUrl, invitation.headline, invitation.note);
      } else if (invitation.invitationType === "companyFollow") {
        console.log(invitation.companyName, invitation.companyUrl);
      } else {
        console.log(invitation.newsletterName, invitation.newsletterUrl);
      }
    }
  }
} catch (e) {
  // A list of all critical errors can be found here:
  // https://linkedapi.io/sdks/handling-results-and-errors/#handling-critical-errors
  if (e instanceof LinkedApiError) {
    console.error(`Critical Error - Type: ${e.type}, Message: ${e.message}`);
  } else {
    console.error("An unexpected, non-API error occurred:", e);
  }
}
```

```python
from linkedapi import LinkedApiError

try:
    workflow = linkedapi.retrieve_invitations.execute()

    result = linkedapi.retrieve_invitations.result(workflow.workflow_id)
    data = result.data
    errors = result.errors

    # The list of possible execution errors is below
    if errors:
        print("Workflow completed with execution errors:")
        for error in errors:
            print(f" - Type: {error.type}, Message: {error.message}")

    # The structure of the 'data' object is below
    if data:
        print("Incoming invitations count:", len(data))
        for invitation in data:
            print(f"{invitation.invitation_type}: {invitation.name}")
            if invitation.invitation_type == "connect":
                print(invitation.public_url, invitation.headline, invitation.note)
            elif invitation.invitation_type == "companyFollow":
                print(invitation.company_name, invitation.company_url)
            else:
                print(invitation.newsletter_name, invitation.newsletter_url)
except LinkedApiError as e:
    # A list of all critical errors can be found here:
    # https://linkedapi.io/sdks/handling-results-and-errors/#handling-critical-errors
    print(f"Critical Error - Type: {e.type}, Message: {e.message}")
except Exception as error:
    print("An unexpected, non-API error occurred:", error)
```

## Params

The method doesn't require any parameters.

## Data

Array of incoming invitations. Every item contains:

- `invitationType` – `connect`, `companyFollow`, or `newsletterSubscribe`.
- `name` – name of the person who sent the invitation.
- `publicUrl` – [public](/faq/what-are-hashed-url-and-public-url) LinkedIn URL of that person.

Type-specific fields:

- `connect`: `headline` and `note`, each nullable.
- `companyFollow`: `companyUrl` and nullable `companyName`.
- `newsletterSubscribe`: `newsletterUrl` and nullable `newsletterName`.

## Errors

The method has no execution errors (`errors` is always `[]`).