> ## 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

> Partner invitations with the Go SDK

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")
	}
}
```