Zavu

https://docs.zavu.dev
Admin
Zavu is a unified messaging API that enables sending SMS and WhatsApp messages through a single...
Tokens:1,030,097
Snippets:6,892
Trust Score:4.2
Update:3 hours ago
Show doc for...
Tokens:
Raw
### Install Zavu SDK - Go

Source: https://docs.zavu.dev/guides/integrations/vercel

Install the Zavu SDK for Go using go get.

```bash
go get github.com/zavudev/sdk-go
```

--------------------------------

### Go example to get a tool

Source: https://docs.zavu.dev/api-reference/agent-tools/get-tool

Uses the net/http package to send a GET request and prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}"

	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(string(body))

}
```

--------------------------------

### Go HTTP client to get deployment

Source: https://docs.zavu.dev/api-reference/functions/get-deployment

Go example using net/http to GET a deployment. Requires a Bearer token.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/functions/deployments/{deploymentId}"

	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(string(body))

}
```

--------------------------------

### Go example to get a broadcast

Source: https://docs.zavu.dev/api-reference/get-broadcast

Uses the net/http package to send a GET request and prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/broadcasts/{broadcastId}"

	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(string(body))

}
```

--------------------------------

### Ruby example to get a tool

Source: https://docs.zavu.dev/api-reference/agent-tools/get-tool

Uses Net::HTTP to send a GET request with SSL and prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}")

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

--------------------------------

### Go example for GET /v1/memory/usage

Source: https://docs.zavu.dev/api-reference/memory/get-memory-usage

Uses net/http to send a GET request. Requires an Authorization header with a Bearer token.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/memory/usage"

	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(string(body))

}
```

--------------------------------

### Go example to get a contact

Source: https://docs.zavu.dev/api-reference/get-contact

Uses the net/http package to send a GET request with an authorization header. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/contacts/{contactId}"

	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(string(body))

}
```

--------------------------------

### Go example to get a function

Source: https://docs.zavu.dev/api-reference/functions/get-function

Uses the net/http package to send a GET request to the Zavu API. Requires an Authorization header with a bearer token.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/functions/{functionId}"

	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(string(body))

}
```

--------------------------------

### Full Example: Onboarding Client and Checking Status

Source: https://docs.zavu.dev/sdks/typescript/invitations

Complete example showing SDK initialization, creating an invitation, and checking its status with a switch statement. Includes usage at the end.

```typescript
import Zavudev from "@zavudev/sdk";

const zavu = new Zavudev({
  apiKey: process.env["ZAVUDEV_API_KEY"],
});

async function onboardClient(clientName: string, clientEmail: string) {
  // Create invitation
  const invitation = await zavu.invitations.create({
    clientName,
    clientEmail,
    expiresInDays: 7,
  });

  console.log(`Send this link to ${clientName}: ${invitation.url}`);

  return invitation;
}

async function checkInvitationStatus(invitationId: string) {
  const { invitation } = await zavu.invitations.retrieve({ invitationId });

  switch (invitation.status) {
    case "pending":
      console.log("Waiting for client to start signup");
      break;
    case "in_progress":
      console.log("Client is completing the signup flow");
      break;
    case "completed":
      console.log(`Success! Sender ID: ${invitation.senderId}`);
      break;
    case "expired":
      console.log("Invitation expired, create a new one");
      break;
    case "cancelled":
      console.log("Invitation was cancelled");
      break;
  }

  return invitation;
}

// Usage
const invitation = await onboardClient("Acme Corp", "contact@acme.com");
// Later...
await checkInvitationStatus(invitation.id);
```

--------------------------------

### Quick example in Go

Source: https://docs.zavu.dev/guides/broadcasts/overview

Go example using github.com/zavudev/sdk-go to create a broadcast, add contacts with template variables, send it, and check progress.

```go
package main

import (
	"context"
	"fmt"
	"os"

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

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

	// 1. Create the broadcast
	broadcast, _ := client.Broadcasts.New(context.TODO(), zavudev.BroadcastCreateParams{
		Name:    zavudev.String("Order Confirmation Campaign"),
		Channel: zavudev.String("sms"),
		Text:    zavudev.String("Hi {{name}}, your order #{{order_id}} has shipped!"),
	})

	// 2. Add contacts with personalization
	client.Broadcasts.Contacts.Add(context.TODO(), broadcast.ID, zavudev.BroadcastAddContactsParams{
		Contacts: []zavudev.BroadcastContactInput{
			{
				Recipient:         zavudev.String("+14155551234"),
				TemplateVariables: map[string]string{"name": "John", "order_id": "ORD-001"},
			},
			{
				Recipient:         zavudev.String("+14155555678"),
				TemplateVariables: map[string]string{"name": "Jane", "order_id": "ORD-002"},
			},
		},
	})

	// 3. Send immediately
	client.Broadcasts.Send(context.TODO(), broadcast.ID, zavudev.BroadcastSendParams{})

	// 4. Check progress
	progress, _ := client.Broadcasts.Progress(context.TODO(), broadcast.ID)
	fmt.Printf("%v%% complete\n", progress.PercentComplete)
}
```

--------------------------------

### Java Unirest to get deployment

Source: https://docs.zavu.dev/api-reference/functions/get-deployment

Java example using Unirest to GET a deployment. Requires a Bearer token.

```java
HttpResponse<String> response = Unirest.get("https://api.zavu.dev/v1/functions/deployments/{deploymentId}")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Example Prompt: Full Zavu Project Setup

Source: https://docs.zavu.dev/tools/coding-agent-skills

Prompt for setting up a Zavu project: buy a US phone number, create a sender, configure webhooks for inbound and delivery events, and create an order confirmation WhatsApp template.

```text
"Set up my Zavu project: buy a US phone number, create a sender,
configure webhooks for inbound and delivery events, and create
an order confirmation WhatsApp template"
```

--------------------------------

### PHP cURL to get deployment

Source: https://docs.zavu.dev/api-reference/functions/get-deployment

PHP example using cURL to GET a deployment. Requires a Bearer token.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.zavu.dev/v1/functions/deployments/{deploymentId}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Full Example: Onboard Client and Check Status

Source: https://docs.zavu.dev/sdks/ruby/invitations

Complete workflow: initializes the client, creates an invitation, prints the link, and later checks the invitation status with a case statement.

```ruby
require "zavudev"

client = Zavudev::Client.new(
  api_key: ENV["ZAVUDEV_API_KEY"]
)

def onboard_client(client, client_name, client_email)
  # Create invitation
  invitation = client.invitations.create(
    client_name: client_name,
    client_email: client_email,
    expires_in_days: 7
  )

  puts "Send this link to #{client_name}: #{invitation.url}"
  invitation
end

def check_invitation_status(client, invitation_id)
  result = client.invitations.retrieve(invitation_id: invitation_id)
  invitation = result.invitation

  case invitation.status
  when "pending"
    puts "Waiting for client to start signup"
  when "in_progress"
    puts "Client is completing the signup flow"
  when "completed"
    puts "Success! Sender ID: #{invitation.sender_id}"
  when "expired"
    puts "Invitation expired, create a new one"
  when "cancelled"
    puts "Invitation was cancelled"
  end

  invitation
end

# Usage
invitation = onboard_client(client, "Acme Corp", "contact@acme.com")
# Later...
check_invitation_status(client, invitation.id)
```

--------------------------------

### JavaScript fetch to get deployment

Source: https://docs.zavu.dev/api-reference/functions/get-deployment

JavaScript example using fetch to GET a deployment. Requires a Bearer token.

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.zavu.dev/v1/functions/deployments/{deploymentId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Go example to create knowledge base

Source: https://docs.zavu.dev/api-reference/agent-knowledge-bases/create-knowledge-base

Uses net/http to send a POST request with a JSON payload. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/knowledge-bases"

	payload := strings.NewReader("{\n  \"name\": \"Product FAQ\",\n  \"description\": \"Frequently asked questions about our products\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

```

--------------------------------

### Quick Start: Send a message

Source: https://docs.zavu.dev/sdks/php/overview

Initialize the client with an API key from the environment and send a message. Prints the message ID.

```php
<?php

use Zavudev\Client;

$client = new Client(
    apiKey: getenv('ZAVUDEV_API_KEY')
);

$result = $client->messages->send([
    'to' => '+14155551234',
    'text' => 'Hello from Zavu!',
]);

echo "Message sent: " . $result->message->id . "\n";
```

--------------------------------

### 502 error response example for get regulatory requirements

Source: https://docs.zavu.dev/api-reference/get-regulatory-requirements

Example of a 502 error response when regulatory requirements cannot be retrieved.

```json
{
  "code": "requirements_unavailable",
  "message": "Regulatory requirements could not be retrieved right now. Retry shortly; do not treat this as no requirements."
}
```

--------------------------------

### Get contact response

Source: https://docs.zavu.dev/guides/contacts/overview

Example JSON response from the get contact by ID endpoint, showing contact fields and metadata.

```json
{
  "id": "con_abc123",
  "phoneNumber": "+14155551234",
  "countryCode": "US",
  "profileName": "John Doe",
  "availableChannels": ["sms", "whatsapp"],
  "defaultChannel": "whatsapp",
  "verified": true,
  "metadata": {
    "tier": "premium",
    "source": "website"
  },
  "createdAt": "2024-01-15T10:30:00.000Z",
  "updatedAt": "2024-01-15T12:00:00.000Z"
}
```

--------------------------------

### Go example to list knowledge bases

Source: https://docs.zavu.dev/api-reference/agent-knowledge-bases/list-knowledge-bases

Go example using net/http to call the endpoint. Replace {senderId} and <token> as needed.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/knowledge-bases"

	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(string(body))

}
```

--------------------------------

### Ruby example for GET /v1/memory/usage

Source: https://docs.zavu.dev/api-reference/memory/get-memory-usage

Uses net/http to send a GET request. Requires an Authorization header with a Bearer token.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.zavu.dev/v1/memory/usage")

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

--------------------------------

### Install CLI: npx (recommended)

Source: https://docs.zavu.dev/guides/functions/factory-agents

No install step. Always runs the current version.

```bash
# No install step. Always runs the current version.
npx zavudev@latest --version
```

--------------------------------

### Go example for get regulatory requirements

Source: https://docs.zavu.dev/api-reference/get-regulatory-requirements

Uses the net/http package to send a GET request and print the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/phone-numbers/requirements"

	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(string(body))

}
```

--------------------------------

### Initialize the Client with API key and custom base URL

Source: https://docs.zavu.dev/sdks/go/overview

Shows basic initialization with an API key and optional custom base URL. The second client uses a hardcoded key and a custom base URL.

```go
import (
	"github.com/zavudev/sdk-go"
	"github.com/zavudev/sdk-go/option"
)

// Basic initialization
client := zavudev.NewClient(
	option.WithAPIKey(os.Getenv("ZAVUDEV_API_KEY")),
)

// With custom base URL
client := zavudev.NewClient(
	option.WithAPIKey("zv_live_xxx"),
	option.WithBaseURL("https://api.zavu.dev"),
)
```

--------------------------------

### Go example to create a document

Source: https://docs.zavu.dev/api-reference/agent-knowledge-bases/create-document

Uses net/http to send a POST request with a JSON string body. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/knowledge-bases/{kbId}/documents"

	payload := strings.NewReader("{\n  \"title\": \"Return Policy\",\n  \"content\": \"Our return policy allows returns within 30 days of purchase...\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Python requests example to get a broadcast

Source: https://docs.zavu.dev/api-reference/get-broadcast

Uses the requests library to perform a GET request. Prints the response text.

```python
import requests

url = "https://api.zavu.dev/v1/broadcasts/{broadcastId}"

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

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

print(response.text)
```

--------------------------------

### Ruby example to get a contact

Source: https://docs.zavu.dev/api-reference/get-contact

Uses Net::HTTP to send a GET request with SSL. Prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.zavu.dev/v1/contacts/{contactId}")

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

--------------------------------

### Example Prompt: AI Agent with FAQ Knowledge Base

Source: https://docs.zavu.dev/tools/coding-agent-skills

Prompt for setting up an AI agent with a product FAQ knowledge base that responds to WhatsApp messages and can look up order status via webhook.

```text
"Set up an AI agent with a product FAQ knowledge base that responds
to WhatsApp messages and can look up order status via webhook"
```

--------------------------------

### Initialize the Client

Source: https://docs.zavu.dev/sdks/php/overview

Basic initialization with an API key from the environment, and with a custom base URL.

```php
use Zavudev\Client;

// Basic initialization
$client = new Client(
    apiKey: getenv('ZAVUDEV_API_KEY')
);

// With custom base URL
$client = new Client(
    apiKey: 'zv_live_xxx',
    baseURL: 'https://api.zavu.dev'
);
```

--------------------------------

### Python requests to get deployment

Source: https://docs.zavu.dev/api-reference/functions/get-deployment

Python example using the requests library to GET a deployment. Requires a Bearer token.

```python
import requests

url = "https://api.zavu.dev/v1/functions/deployments/{deploymentId}"

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

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

print(response.text)
```

--------------------------------

### Create knowledge base, add document, and list documents

Source: https://docs.zavu.dev/guides/ai-agents/knowledge-base

Use these CLI commands to create a knowledge base, add a document from a file, and list documents. Processing takes a few seconds; `isProcessed` flips to true and `chunkCount` fills in. Verify retrieval with `npx zavudev agents test`.

```bash
npx zavudev agents knowledge-bases create --sender <senderId> --name "Product docs"
npx zavudev agents knowledge-bases documents add --sender <senderId> --kb <kbId> \
  --title "Pricing" --content-file ./pricing.md
npx zavudev agents knowledge-bases documents list --sender <senderId> --kb <kbId>
```

--------------------------------

### Go example for listing tool test runs

Source: https://docs.zavu.dev/api-reference/agent-tools/list-tool-test-runs

Go example using net/http to GET the test-runs endpoint. Sets the Authorization header and prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}/test-runs"

	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(string(body))

}
```

--------------------------------

### JavaScript fetch example to get a tool

Source: https://docs.zavu.dev/api-reference/agent-tools/get-tool

Uses fetch to make a GET request and logs the JSON response or error.

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Python requests example to get a tool

Source: https://docs.zavu.dev/api-reference/agent-tools/get-tool

Uses the requests library to perform a GET request. Prints the response text.

```python
import requests

url = "https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}"

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

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

print(response.text)
```

--------------------------------

### Initialize restaurant-booking template with CLI

Source: https://docs.zavu.dev/guides/functions/examples/restaurant

Use this command to scaffold the restaurant-booking template. It requires the Zavu CLI and creates a project with the template.

```bash
npx zavudev fn init --template restaurant-booking -y
```

--------------------------------

### Quick example in Python

Source: https://docs.zavu.dev/guides/broadcasts/overview

Python example using zavudev to create a broadcast, add contacts with template variables, send it, and check progress.

```python
import os
from zavudev import Zavudev

zavu = Zavudev(
    api_key=os.environ.get("ZAVUDEV_API_KEY"),  # This is the default and can be omitted
)

# 1. Create the broadcast
broadcast = zavu.broadcasts.create(
    name="Order Confirmation Campaign",
    channel="sms",
    text="Hi {{name}}, your order #{{order_id}} has shipped!"
)

# 2. Add contacts with personalization
zavu.broadcasts.contacts.add(broadcast.id, contacts=[
    {
        "recipient": "+14155551234",
        "templateVariables": {"name": "John", "order_id": "ORD-001"}
    },
    {
        "recipient": "+14155555678",
        "templateVariables": {"name": "Jane", "order_id": "ORD-002"}
    },
])

# 3. Send immediately
zavu.broadcasts.send(broadcast.id)

# 4. Check progress
progress = zavu.broadcasts.progress(broadcast.id)
print(f"{progress.percent_complete}% complete")
```

--------------------------------

### 200 response example for get regulatory requirements

Source: https://docs.zavu.dev/api-reference/get-regulatory-requirements

Example of a successful response containing a list of regulatory requirements for a phone number.

```json
{
  "items": [
    {
      "id": "+4930123456",
      "countryCode": "DE",
      "phoneNumberType": "local",
      "action": "ordering",
      "requirementTypes": [
        {
          "id": "8c5b1a2e-0f3d-4f5b-9a61-2c7e4d9b1f10",
          "name": "Address",
          "description": "An address in Germany",
          "type": "address"
        },
        {
          "id": "3f9e2d41-7b6a-4c1e-8d52-9a0b1c2d3e4f",
          "name": "Identity document",
          "description": "A copy of an identity document",
          "type": "document"
        }
      ]
    }
  ]
}
```

--------------------------------

### Java Unirest example for GET /v1/memory/usage

Source: https://docs.zavu.dev/api-reference/memory/get-memory-usage

Uses Unirest to send a GET request. Requires an Authorization header with a Bearer token.

```java
HttpResponse<String> response = Unirest.get("https://api.zavu.dev/v1/memory/usage")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Go example to create address

Source: https://docs.zavu.dev/api-reference/regulatory/create-address

Uses net/http to POST the address payload. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/addresses"

	payload := strings.NewReader("{\n  \"firstName\": \"John\",\n  \"lastName\": \"Doe\",\n  \"streetAddress\": \"123 Main St\",\n  \"locality\": \"Berlin\",\n  \"postalCode\": \"10115\",\n  \"countryCode\": \"DE\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Python requests example for get regulatory requirements

Source: https://docs.zavu.dev/api-reference/get-regulatory-requirements

Uses the requests library to perform a GET request and print the response text.

```python
import requests

url = "https://api.zavu.dev/v1/phone-numbers/requirements"

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

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

print(response.text)
```

--------------------------------

### Quick example in TypeScript

Source: https://docs.zavu.dev/guides/broadcasts/overview

TypeScript example using @zavudev/sdk to create a broadcast, add contacts with template variables, send it, and check progress.

```typescript
import Zavudev from '@zavudev/sdk';

const zavu = new Zavudev({
  apiKey: process.env['ZAVUDEV_API_KEY'], // This is the default and can be omitted
});

// 1. Create the broadcast
const broadcast = await zavu.broadcasts.create({
  name: "Order Confirmation Campaign",
  channel: "sms",
  text: "Hi {{name}}, your order #{{order_id}} has shipped!",
});

// 2. Add contacts with personalization
await zavu.broadcasts.contacts.add(broadcast.id, {
  contacts: [
    {
      recipient: "+14155551234",
      templateVariables: { name: "John", order_id: "ORD-001" }
    },
    {
      recipient: "+14155555678",
      templateVariables: { name: "Jane", order_id: "ORD-002" }
    },
  ],
});

// 3. Send immediately
await zavu.broadcasts.send(broadcast.id);

// 4. Check progress
const progress = await zavu.broadcasts.progress(broadcast.id);
console.log(`${progress.percentComplete}% complete`);
```

--------------------------------

### Java Unirest example to get a broadcast

Source: https://docs.zavu.dev/api-reference/get-broadcast

Uses the Unirest HTTP library to send a GET request and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.zavu.dev/v1/broadcasts/{broadcastId}")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Go example to update knowledge base

Source: https://docs.zavu.dev/api-reference/agent-knowledge-bases/update-knowledge-base

Uses net/http to send a PATCH request with a JSON body. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/knowledge-bases/{kbId}"

	payload := strings.NewReader("{\n  \"name\": \"<string>\",\n  \"description\": \"<string>\"\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### PHP cURL example to get a broadcast

Source: https://docs.zavu.dev/api-reference/get-broadcast

Uses PHP cURL to perform a GET request. Outputs the response or a cURL error.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.zavu.dev/v1/broadcasts/{broadcastId}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Initialize Client with Basic and Custom Base URL

Source: https://docs.zavu.dev/sdks/ruby/overview

Shows basic initialization with an API key from the environment and a custom base URL with a hardcoded key.

```ruby
require "zavudev"

# Basic initialization
client = Zavudev::Client.new(
  api_key: ENV["ZAVUDEV_API_KEY"]
)

# With custom base URL
client = Zavudev::Client.new(
  api_key: "zv_live_xxx",
  base_url: "https://api.zavu.dev"
)
```

--------------------------------

### JavaScript fetch example to get a broadcast

Source: https://docs.zavu.dev/api-reference/get-broadcast

Uses the fetch API to make a GET request and logs the JSON response or error.

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.zavu.dev/v1/broadcasts/{broadcastId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Build an agent, connect a sender, and enable it (cURL)

Source: https://docs.zavu.dev/concepts/agent-architecture

Create an agent via POST /v1/agents, add tools and knowledge bases, then connect a sender and enable the agent. The agent will not receive anything until a sender is connected and enabled.

```bash
# Build an agent before it answers anywhere
AGENT=$(curl -s -X POST https://api.zavu.dev/v1/agents \
  -H "Authorization: Bearer $ZAVUDEV_API_KEY" \
  -d '{"name":"Ada","provider":"zavu","model":"openai/gpt-5.6-luna","systemPrompt":"..."}' \
  | jq -r .agent.id)

curl -X POST https://api.zavu.dev/v1/agents/$AGENT/tools -d '{...}'
curl -X POST https://api.zavu.dev/v1/agents/$AGENT/knowledge-bases -d '{...}'

# Then connect a sender and enable it
curl -X POST https://api.zavu.dev/v1/agents/$AGENT/senders -d "{\"senderId\":\"$SENDER_ID\"}"
curl -X PATCH https://api.zavu.dev/v1/agents/$AGENT -d '{"enabled":true}'
```

--------------------------------

### Java Unirest example to get a contact

Source: https://docs.zavu.dev/api-reference/get-contact

Uses the Unirest HTTP library to send a GET request. Returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.zavu.dev/v1/contacts/{contactId}")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Go example to update a tool

Source: https://docs.zavu.dev/api-reference/agent-tools/update-tool

Uses the net/http package to send a PATCH request with a JSON payload. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}"

	payload := strings.NewReader("{\n  \"name\": \"<string>\",\n  \"description\": \"<string>\",\n  \"webhookUrl\": \"<string>\",\n  \"webhookSecret\": \"<string>\",\n  \"enabled\": true\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Initialize Zavu Client with custom base URL

Source: https://docs.zavu.dev/sdks/typescript/overview

Shows basic initialization and how to set a custom base URL. The second example uses a hardcoded API key and baseURL.

```typescript
import Zavudev from '@zavudev/sdk';

// Basic initialization
const zavu = new Zavudev({
  apiKey: process.env['ZAVUDEV_API_KEY'],
});

// With custom base URL
const zavu = new Zavudev({
  apiKey: "zv_live_xxx",
  baseURL: "https://api.zavu.dev",
});
```

--------------------------------

### Ruby Net::HTTP to get deployment

Source: https://docs.zavu.dev/api-reference/functions/get-deployment

Ruby example using Net::HTTP to GET a deployment. Requires a Bearer token.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.zavu.dev/v1/functions/deployments/{deploymentId}")

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

--------------------------------

### Setup commands for Zavu Functions

Source: https://docs.zavu.dev/guides/functions/examples/customer-support

Initializes a new Zavu function with slug 'support' and changes into the directory.

```bash
npx zavudev fn init --slug support -y
cd support
```

--------------------------------

### Go example for getting an email domain

Source: https://docs.zavu.dev/api-reference/email-domains/get-an-email-domain

Uses net/http to send a GET request with an Authorization header and prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/email-domains/{domainId}"

	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(string(body))

}
```

--------------------------------

### Example Prompt: Express Webhook Server

Source: https://docs.zavu.dev/tools/coding-agent-skills

Prompt for creating an Express server that receives Zavu webhooks, verifies signatures, and stores inbound messages in Postgres.

```text
"Create an Express server that receives Zavu webhooks, verifies
signatures, and stores inbound messages in Postgres"
```

--------------------------------

### JavaScript fetch example for getting an email domain

Source: https://docs.zavu.dev/api-reference/email-domains/get-an-email-domain

Uses fetch to send a GET request and logs the JSON response or error.

```javascript
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://api.zavu.dev/v1/email-domains/{domainId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Install CLI: Standalone binary

Source: https://docs.zavu.dev/guides/functions/factory-agents

Downloads the standalone binary from GitHub releases, makes it executable, and moves it to /usr/local/bin.

```bash
# Download from https://github.com/zavudev/zavu-cli/releases, then:
chmod +x ./zavu-macos-arm64
sudo mv ./zavu-macos-arm64 /usr/local/bin/zavudev
```

--------------------------------

### Python requests example for getting an email domain

Source: https://docs.zavu.dev/api-reference/email-domains/get-an-email-domain

Uses the requests library to perform a GET request. Prints the response text.

```python
import requests

url = "https://api.zavu.dev/v1/email-domains/{domainId}"

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

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

print(response.text)
```

--------------------------------

### Java Unirest example to get a tool

Source: https://docs.zavu.dev/api-reference/agent-tools/get-tool

Uses the Unirest HTTP library to send a GET request and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.zavu.dev/v1/senders/{senderId}/agent/tools/{toolId}")
  .header("Authorization", "Bearer <token>")
  .asString();
```

--------------------------------

### Create knowledge base with Go

Source: https://docs.zavu.dev/api-reference/agent-knowledge-bases/create-knowledge-base

Uses net/http to POST a new knowledge base. Prints the response body.

```go
package main

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

func main() {

	url := "https://api.zavu.dev/v1/senders/{senderId}/agent/knowledge-bases"

	payload := strings.NewReader("{\n  \"name\": \"Product FAQ\",\n  \"description\": \"Frequently asked questions about our products\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```
Tokens:
Raw