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

# Invitations

> Generate partner invitations for client WhatsApp Business onboarding via the Zavu Go SDK. Track status and manage expiration.

Partner invitations allow you to generate links for clients to connect their WhatsApp Business accounts to your project.

## Create Invitation

```go theme={null}
result, err := client.Invitations.Create(context.TODO(), zavudev.InvitationCreateParams{
	ClientName:    zavudev.String("Acme Corp"),
	ClientEmail:   zavudev.String("contact@acme.com"),
	ExpiresInDays: zavudev.Int(14),
})
if err != nil {
	panic(err)
}

fmt.Println(result.Invitation.ID)     // jh7am5bng9p3v2x1k4r8
fmt.Println(result.Invitation.URL)    // https://dashboard.zavu.dev/invite/abc123xyz
fmt.Println(result.Invitation.Status) // pending
```

### With Phone Number Restrictions

Restrict which countries the client can register phone numbers from:

```go theme={null}
result, err := client.Invitations.Create(context.TODO(), zavudev.InvitationCreateParams{
	ClientName:           zavudev.String("Acme Corp"),
	ClientEmail:          zavudev.String("contact@acme.com"),
	ExpiresInDays:        zavudev.Int(7),
	AllowedPhoneCountries: []string{"US", "MX"},
})
```

## Get Invitation

```go theme={null}
result, err := client.Invitations.Get(context.TODO(), "jh7am5bng9p3v2x1k4r8")
if err != nil {
	panic(err)
}

fmt.Println(result.Invitation.Status)     // pending | in_progress | completed | expired | cancelled
fmt.Println(result.Invitation.ClientName) // Acme Corp
fmt.Println(result.Invitation.SenderID)   // "" (until completed)
fmt.Println(result.Invitation.ExpiresAt)  // 2025-01-15T00:00:00.000Z
```

## List Invitations

```go theme={null}
result, err := client.Invitations.List(context.TODO(), zavudev.InvitationListParams{})
if err != nil {
	panic(err)
}

for _, invitation := range result.Items {
	fmt.Println(invitation.ID, invitation.ClientName, invitation.Status)
}
```

### Filter by Status

```go theme={null}
result, err := client.Invitations.List(context.TODO(), zavudev.InvitationListParams{
	Status: zavudev.String("pending"),
	Limit:  zavudev.Int(50),
})
```

### Pagination

```go theme={null}
var cursor *string

for {
	result, err := client.Invitations.List(context.TODO(), zavudev.InvitationListParams{
		Limit:  zavudev.Int(50),
		Cursor: cursor,
	})
	if err != nil {
		panic(err)
	}

	for _, invitation := range result.Items {
		fmt.Println(invitation.ID)
	}

	if result.NextCursor == nil {
		break
	}
	cursor = result.NextCursor
}
```

## Cancel Invitation

Cancel an active invitation to prevent the client from using it:

```go theme={null}
result, err := client.Invitations.Cancel(context.TODO(), "jh7am5bng9p3v2x1k4r8")
if err != nil {
	panic(err)
}

fmt.Println(result.Invitation.Status) // cancelled
```

<Note>
  You cannot cancel a completed invitation. Once a sender is created, manage it through the senders API.
</Note>

## After Completion

When a client completes the signup flow, a sender is created in your project:

```go theme={null}
result, err := client.Invitations.Get(context.TODO(), "jh7am5bng9p3v2x1k4r8")
if err != nil {
	panic(err)
}

if result.Invitation.Status == "completed" && result.Invitation.SenderID != "" {
	// Use the sender to send messages
	_, err := client.Messages.Send(context.TODO(), zavudev.MessageSendParams{
		To:          zavudev.String("+14155551234"),
		Channel:     zavudev.String("whatsapp"),
		MessageType: zavudev.String("template"),
		Content: &zavudev.MessageContent{
			TemplateID: zavudev.String("tmpl_xyz789"),
			TemplateVariables: map[string]string{
				"1": "John",
			},
		},
		ZavuSender: zavudev.String(result.Invitation.SenderID),
	})
	if err != nil {
		panic(err)
	}
}
```

## Full Example

```go theme={null}
package main

import (
	"context"
	"fmt"
	"os"

	"github.com/zavudev/sdk-go"
	"github.com/zavudev/sdk-go/option"
)

func main() {
	client := zavudev.NewClient(
		option.WithAPIKey(os.Getenv("ZAVUDEV_API_KEY")),
	)

	invitation, err := onboardClient(client, "Acme Corp", "contact@acme.com")
	if err != nil {
		panic(err)
	}

	// Later...
	checkInvitationStatus(client, invitation.Invitation.ID)
}

func onboardClient(client *zavudev.Client, clientName, clientEmail string) (*zavudev.InvitationResponse, error) {
	result, err := client.Invitations.Create(context.TODO(), zavudev.InvitationCreateParams{
		ClientName:    zavudev.String(clientName),
		ClientEmail:   zavudev.String(clientEmail),
		ExpiresInDays: zavudev.Int(7),
	})
	if err != nil {
		return nil, err
	}

	fmt.Printf("Send this link to %s: %s\n", clientName, result.Invitation.URL)
	return result, nil
}

func checkInvitationStatus(client *zavudev.Client, invitationID string) {
	result, err := client.Invitations.Get(context.TODO(), invitationID)
	if err != nil {
		panic(err)
	}

	switch result.Invitation.Status {
	case "pending":
		fmt.Println("Waiting for client to start signup")
	case "in_progress":
		fmt.Println("Client is completing the signup flow")
	case "completed":
		fmt.Printf("Success! Sender ID: %s\n", result.Invitation.SenderID)
	case "expired":
		fmt.Println("Invitation expired, create a new one")
	case "cancelled":
		fmt.Println("Invitation was cancelled")
	}
}
```