Client SDKs

npm install vendel-sdk

go get github.com/JimScope/vendel-sdk-go

import { VendelClient } from "vendel-sdk";

const client = new VendelClient({
  baseUrl: "https://app.vendel.cc",
  apiKey: "vk_your_api_key",
});
const response = await client.sendSms(["+1234567890"], "Hello from Vendel!");

package main

import (
	"context"
	"fmt"
	vendel "github.com/JimScope/vendel-sdk-go"
)

func main() {
	client := vendel.NewClient("https://app.vendel.cc", "vk_your_api_key")
	resp, err := client.SendSMS(context.Background(), vendel.SendSMSRequest{
		Recipients: []string{"+1234567890"},
		Body:       "Hello from Vendel!",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println("Batch ID:", resp.BatchID)
}

const response = await client.sendSms(
  ["+1234567890", "+0987654321"],
  "Your order has shipped!",
  { deviceId: "optional_device_id" },
);
console.log(`Batch: ${response.batch_id}, Messages: ${response.message_ids}`);

resp, err := client.SendSMS(ctx, vendel.SendSMSRequest{
	Recipients: []string{"+1234567890", "+0987654321"},
	Body:       "Your order has shipped!",
	DeviceID:   "optional_device_id",
})
fmt.Printf("Batch: %s, Messages: %v\n", resp.BatchID, resp.MessageIDs)

const response = await client.sendSms(
  ["+1234567890"],
  "Flash sale starts now!",
  { groupIds: ["group_abc", "group_xyz"] },
);
console.log(`Sent to ${response.recipients_count} recipients`);

resp, err := client.SendSMS(ctx, vendel.SendSMSRequest{
	Recipients: []string{"+1234567890"},
	Body:       "Flash sale starts now!",
	GroupIDs:   []string{"group_abc", "group_xyz"},
})
fmt.Printf("Sent to %d recipients\n", resp.RecipientsCount)

const response = await client.sendSmsTemplate(
  ["+1234567890"],
  "template_abc",
  {
    variables: { code: "1234", expiry: "10 minutes" },
    groupIds: ["vip_customers"],
  },
);
console.log(`Batch: ${response.batch_id}`);

resp, err := client.SendSMSTemplate(ctx, vendel.SendSMSTemplateRequest{
	Recipients: []string{"+1234567890"},
	TemplateID: "template_abc",
	Variables:  map[string]string{"code": "1234", "expiry": "10 minutes"},
	GroupIDs:   []string{"vip_customers"},
})
fmt.Printf("Batch: %s\n", resp.BatchID)

const quota = await client.getQuota();
console.log(`Plan: ${quota.plan}`);
console.log(`SMS: ${quota.sms_sent_this_month}/${quota.max_sms_per_month}`);
console.log(`Devices: ${quota.devices_registered}/${quota.max_devices}`);
console.log(`Resets: ${quota.reset_date}`);

quota, err := client.GetQuota(ctx)
fmt.Printf("Plan: %s\n", quota.Plan)
fmt.Printf("SMS: %d/%d\n", quota.SMSSentThisMonth, quota.MaxSMSPerMonth)
fmt.Printf("Devices: %d/%d\n", quota.DevicesRegistered, quota.MaxDevices)
fmt.Printf("Resets: %s\n", quota.ResetDate)

const status = await client.getMessageStatus("MESSAGE_ID");
console.log(`Status: ${status.status}`);
console.log(`Recipient: ${status.recipient}`);
if (status.error_message) {
  console.log(`Error: ${status.error_message}`);
}

status, err := client.GetMessageStatus(ctx, "MESSAGE_ID")
fmt.Printf("Status: %s\n", status.Status)
fmt.Printf("Recipient: %s\n", status.Recipient)
if status.ErrorMessage != "" {
	fmt.Printf("Error: %s\n", status.ErrorMessage)
}

const batch = await client.getBatchStatus("BATCH_ID");
console.log(`Total: ${batch.total}`);
console.log(`Status counts:`, batch.status_counts);
for (const msg of batch.messages) {
  console.log(`  ${msg.recipient}: ${msg.status}`);
}

batch, err := client.GetBatchStatus(ctx, "BATCH_ID")
fmt.Printf("Total: %d\n", batch.Total)
fmt.Printf("Status counts: %v\n", batch.StatusCounts)
for _, msg := range batch.Messages {
	fmt.Printf("  %s: %s\n", msg.Recipient, msg.Status)
}

const contacts = await client.listContacts({ search: "Alice", perPage: 20 });
console.log(`Found ${contacts.total_items} contacts`);
for (const c of contacts.items) {
  console.log(`  ${c.name}: ${c.phone_number}`);
}

contacts, err := client.ListContacts(ctx, vendel.ListContactsParams{
	Search:  "Alice",
	PerPage: 20,
})
fmt.Printf("Found %d contacts\n", contacts.TotalItems)
for _, c := range contacts.Items {
	fmt.Printf("  %s: %s\n", c.Name, c.PhoneNumber)
}

const groups = await client.listContactGroups({ perPage: 50 });
console.log(`Found ${groups.total_items} groups`);
for (const g of groups.items) {
  console.log(`  ${g.id}: ${g.name}`);
}

groups, err := client.ListContactGroups(ctx, 1, 50)
fmt.Printf("Found %d groups\n", groups.TotalItems)
for _, g := range groups.Items {
	fmt.Printf("  %s: %s\n", g.ID, g.Name)
}

import { verifyWebhookSignature } from "vendel-sdk";
import express from "express";

const app = express();
app.use(express.raw({ type: "application/json" }));

app.post("/webhook", (req, res) => {
  const signature = req.headers["x-webhook-signature"] as string;
  const isValid = verifyWebhookSignature(
    req.body.toString(),
    signature,
    "your_webhook_secret",
  );
  if (!isValid) return res.status(401).send("Invalid signature");

  const event = JSON.parse(req.body.toString());
  console.log("Event:", event.event);
  res.sendStatus(200);
});

import (
	"io"
	"net/http"
	vendel "github.com/JimScope/vendel-sdk-go"
)

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	body, _ := io.ReadAll(r.Body)
	signature := r.Header.Get("X-Webhook-Signature")

	if !vendel.VerifyWebhookSignature(string(body), signature, "your_webhook_secret") {
		http.Error(w, "Invalid signature", http.StatusUnauthorized)
		return
	}

	// Process the event...
	w.WriteHeader(http.StatusOK)
}

import { VendelClient, VendelQuotaError, VendelAPIError } from "vendel-sdk";

try {
  await client.sendSms(["+1234567890"], "Hello");
} catch (e) {
  if (e instanceof VendelQuotaError) {
    console.log(`Quota exceeded: ${e.used}/${e.limit} used, ${e.available} remaining`);
  } else if (e instanceof VendelAPIError) {
    console.log(`API error [${e.statusCode}]: ${e.message}`);
  }
}

resp, err := client.SendSMS(ctx, req)
if err != nil {
	if vendel.IsQuotaError(err) {
		qe := err.(*vendel.QuotaError)
		fmt.Printf("Quota exceeded: %d/%d used, %d remaining\n", qe.Used, qe.Limit, qe.Available)
	} else if vendel.IsAPIError(err) {
		ae := err.(*vendel.VendelError)
		fmt.Printf("API error [%d]: %s\n", ae.StatusCode, ae.Message)
	} else {
		fmt.Printf("Network error: %v\n", err)
	}
}