Go SDK

go get github.com/ArkHQ-io/ark-go

go get github.com/ArkHQ-io/[email protected]

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/ArkHQ-io/ark-go"
    "github.com/ArkHQ-io/ark-go/option"
)

func main() {
    // Initialize the client (uses ARK_API_KEY env var by default)
    client := ark.NewClient()

    // Send an email
    email, err := client.Emails.Send(context.Background(), ark.EmailSendParams{
        From:    "Security <[email protected]>",
        To:      []string{"[email protected]"},
        Subject: "Reset your password",
        HTML:    ark.String("<h1>Password Reset</h1><p>Click the link to reset.</p>"),
        Text:    ark.String("Password Reset\n\nClick the link to reset."),
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Email ID: %s\n", email.Data.ID)
    fmt.Printf("Status: %s\n", email.Data.Status)
}

import (
    "github.com/ArkHQ-io/ark-go"
    "github.com/ArkHQ-io/ark-go/option"
)

client := ark.NewClient(
    option.WithAPIKey("ark_..."),                      // Required (or set ARK_API_KEY env var)
    option.WithBaseURL("https://api.arkhq.io/v1"),    // API base URL (rarely needed)
    option.WithMaxRetries(2),                          // Number of retry attempts (default: 2)
)

export ARK_API_KEY="ark_live_..."

// Required string fields (passed directly)
From:    "[email protected]",
Subject: "Hello World",

// Required string slices (passed directly)
To: []string{"[email protected]"},

// Optional string fields - use ark.String()
HTML: ark.String("<h1>Welcome!</h1>"),
Text: ark.String("Plain text version"),

// Optional string slice fields - use ark.StringSlice()
CC: ark.StringSlice([]string{"[email protected]"}),

// Boolean fields
TrackOpens: ark.Bool(true),

// Integer fields
PerPage: ark.Int(25),

import (
    "errors"
    "github.com/ArkHQ-io/ark-go"
)

email, err := client.Emails.Send(ctx, params)
if err != nil {
    var arkErr *ark.Error
    if errors.As(err, &arkErr) {
        fmt.Printf("Status: %d\n", arkErr.StatusCode)
        fmt.Printf("Message: %s\n", arkErr.Message)
        fmt.Printf("Code: %s\n", arkErr.Code)

        switch arkErr.StatusCode {
        case 400:
            fmt.Println("Bad request - check your parameters")
        case 401:
            fmt.Println("Authentication failed - check your API key")
        case 403:
            fmt.Println("Permission denied")
        case 404:
            fmt.Println("Resource not found")
        case 429:
            fmt.Println("Rate limited - slow down requests")
        default:
            fmt.Println("Server error")
        }
    } else {
        // Network or other error
        fmt.Printf("Error: %v\n", err)
    }
    return
}

email, err := client.Emails.Send(ctx, params)
if err != nil {
    var arkErr *ark.Error
    if errors.As(err, &arkErr) {
        fmt.Println(arkErr.DumpRequest(true))   // Include body
        fmt.Println(arkErr.DumpResponse(true))  // Include body
    }
}

import (
    "context"
    "time"
)

// Timeout for a single request
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

email, err := client.Emails.Send(ctx, params)

// Per-request timeout option
email, err := client.Emails.Send(ctx, params,
    option.WithRequestTimeout(5*time.Second),
)

import (
    "context"
    "sync"
)

func sendWelcomeEmails(users []User) {
    client := ark.NewClient()
    ctx := context.Background()

    var wg sync.WaitGroup
    results := make(chan string, len(users))
    errors := make(chan error, len(users))

    for _, user := range users {
        wg.Add(1)
        go func(u User) {
            defer wg.Done()

            email, err := client.Emails.Send(ctx, ark.EmailSendParams{
                From:    "[email protected]",
                To:      []string{u.Email},
                Subject: fmt.Sprintf("Welcome, %s!", u.Name),
                HTML:    ark.String("<h1>Hello!</h1>"),
            })
            if err != nil {
                errors <- err
                return
            }
            results <- email.Data.ID
        }(user)
    }

    wg.Wait()
    close(results)
    close(errors)

    for id := range results {
        fmt.Printf("Sent: %s\n", id)
    }
    for err := range errors {
        fmt.Printf("Error: %v\n", err)
    }
}

import "golang.org/x/sync/errgroup"

func sendEmails(ctx context.Context, users []User) error {
    client := ark.NewClient()
    g, ctx := errgroup.WithContext(ctx)

    // Limit concurrency
    g.SetLimit(10)

    for _, user := range users {
        u := user // Capture variable
        g.Go(func() error {
            _, err := client.Emails.Send(ctx, ark.EmailSendParams{
                From:    "[email protected]",
                To:      []string{u.Email},
                Subject: "Welcome!",
                HTML:    ark.String("<h1>Hello!</h1>"),
            })
            return err
        })
    }

    return g.Wait()
}

import "net/http"

var response *http.Response

email, err := client.Emails.Send(ctx, params,
    option.WithResponseInto(&response),
)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Status: %d\n", response.StatusCode)
fmt.Printf("Request ID: %s\n", response.Header.Get("X-Request-ID"))

email, err := client.Emails.Send(ctx, params,
    option.WithHeader("X-Custom-Header", "value"),
)

email, err := client.Emails.Get(ctx, "msg_abc123")
if err != nil {
    log.Fatal(err)
}

// Check for extra fields not in the type definition
if val, ok := email.Data.ExtraFields["newField"]; ok {
    fmt.Printf("New field: %v\n", val)
}

import "github.com/google/uuid"

idempotencyKey := uuid.New().String()

email, err := client.Emails.Send(ctx, ark.EmailSendParams{
    From:           "[email protected]",
    To:             []string{"[email protected]"},
    Subject:        "Order Confirmation",
    HTML:           ark.String("<p>Your order is confirmed.</p>"),
    IdempotencyKey: ark.String(idempotencyKey),
})

import (
    "github.com/gin-gonic/gin"
    "github.com/ArkHQ-io/ark-go"
)

var arkClient = ark.NewClient()

func main() {
    r := gin.Default()

    r.POST("/send-email", func(c *gin.Context) {
        var req struct {
            To      string `json:"to"`
            Subject string `json:"subject"`
            HTML    string `json:"html"`
        }
        if err := c.BindJSON(&req); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }

        email, err := arkClient.Emails.Send(c.Request.Context(), ark.EmailSendParams{
            From:    "[email protected]",
            To:      []string{req.To},
            Subject: req.Subject,
            HTML:    ark.String(req.HTML),
        })
        if err != nil {
            c.JSON(500, gin.H{"error": err.Error()})
            return
        }

        c.JSON(200, gin.H{"email_id": email.Data.ID})
    })

    r.Run()
}

import (
    "github.com/labstack/echo/v4"
    "github.com/ArkHQ-io/ark-go"
)

var arkClient = ark.NewClient()

func main() {
    e := echo.New()

    e.POST("/send-email", func(c echo.Context) error {
        var req struct {
            To      string `json:"to"`
            Subject string `json:"subject"`
            HTML    string `json:"html"`
        }
        if err := c.Bind(&req); err != nil {
            return err
        }

        email, err := arkClient.Emails.Send(c.Request().Context(), ark.EmailSendParams{
            From:    "[email protected]",
            To:      []string{req.To},
            Subject: req.Subject,
            HTML:    ark.String(req.HTML),
        })
        if err != nil {
            return err
        }

        return c.JSON(200, map[string]string{"email_id": email.Data.ID})
    })

    e.Start(":8080")
}

import (
    "github.com/gofiber/fiber/v2"
    "github.com/ArkHQ-io/ark-go"
)

var arkClient = ark.NewClient()

func main() {
    app := fiber.New()

    app.Post("/send-email", func(c *fiber.Ctx) error {
        var req struct {
            To      string `json:"to"`
            Subject string `json:"subject"`
            HTML    string `json:"html"`
        }
        if err := c.BodyParser(&req); err != nil {
            return err
        }

        email, err := arkClient.Emails.Send(c.Context(), ark.EmailSendParams{
            From:    "[email protected]",
            To:      []string{req.To},
            Subject: req.Subject,
            HTML:    ark.String(req.HTML),
        })
        if err != nil {
            return err
        }

        return c.JSON(fiber.Map{"email_id": email.Data.ID})
    })

    app.Listen(":8080")
}