Skip to content
Support this libraryStar on GitHub

Notification Library for Go ​

notification logo

One Go API for chat, email, SMS, push, and on-call alerts.

CISecurityv0.1.0Go 1.24 or newerMIT licenseUnit statement coverageExecuted unit testsExecuted native integration tests

Features · Quick Start · Drivers · Installation · Examples · API

Features ​

FeatureWhat you get
Simple messagesSend a title and body through a configured driver.
Recipient policyOptionally resolve recipients and apply channel preferences and fallback.
Typed channelsRender channel-specific content with typed renderers and transports.
Explicit identityOptional process-local deduplication preserves accepted channels.
Safe diagnosticsBuilt-in errors and logs omit endpoints, credentials and message content.
Isolated testingCapture messages through the Sender interface.

Quick Start ​

Requires Go 1.24+. Try the complete example without credentials or an external service:

sh
git clone --branch v0.1.0 --depth 1 https://github.com/goforj/notification.git
cd notification
go run ./examples/quickstart

Configure a driver once, then send a title and body. The complete program includes the imports:

go
driver := log.New(slog.New(slog.NewTextHandler(io.Discard, nil)))
notifier := notification.New(driver)

err := notifier.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("message captured")
// message captured

The log driver records a local capture without logging message content. Replace it with a provider driver to use the same Send call for real notifications. Send is synchronous and performs no retries or background work. Success means the driver handled the message, not that the recipient received it.

For your own application, use the installation commands below. The commands use @latest to select the newest published release.

Drivers ​

DriverAcceptanceVerification
Amazon SNSNative SNS message IDProtocol tests
Apple APNsHTTP/2 acceptance and request IDProtocol tests
Apprise APINon-streaming relay acceptanceProtocol tests
BarkNative response codeProtocol tests
Better StackNative incident ID; actions preserve IDProtocol tests
ClickSendNative envelope and per-message resultProtocol tests
DingTalkRobot response codeProtocol tests
DiscordMessage IDProtocol tests
ExpoNative push ticket; not a delivery receiptProtocol tests
FeishuBot response codeProtocol tests
Firebase Cloud MessagingProject-scoped native message nameProtocol tests
FireHydrantNative Signals acceptanceProtocol tests
GoAlertGeneric Incoming acceptanceProtocol tests
Google ChatMessage resourceProtocol tests
GotifyMessage ID and contentGotify 3.1.1
Home AssistantNotify service responseProtocol tests
IFTTTEvent-trigger acknowledgementProtocol tests
ilertHTTP 202 event acceptanceProtocol tests
incident.ioCorrelated event acceptanceProtocol tests
Jira Service ManagementAsync request IDProtocol tests
JoinNative success flagProtocol tests
LINEPush acknowledgementProtocol tests
LogLocal captureLocal capture
MailMailer acceptanceComposition tests
MatrixEvent ID; fresh transaction per SendSynapse 1.164.2
MattermostNative ok acknowledgementProtocol tests
Nextcloud TalkOCS status and message IDProtocol tests
ntfyMessage ID and topicntfy 2.37.2
OneSignalNative message ID and recipient checksProtocol tests
OpsgenieAsync request IDProtocol tests
PagerDutyEvent and incident keyProtocol tests
PagerTreeNative integration acceptanceProtocol tests
PlivoNative request and message UUIDProtocol tests
PushbulletNative push IDProtocol tests
PushoverNative status and request IDProtocol tests
Rocket.ChatNative success flagProtocol tests
Signal relayNative send timestampProtocol tests
SIGNL4Native webhook acceptanceProtocol tests
Slackok acknowledgementProtocol tests
TeamsHTTP acceptanceProtocol tests
TelegramMessage IDProtocol tests
TelnyxRecipient-correlated message statusProtocol tests
TwilioMessage SID and statusProtocol tests
VonageAll SMS segments acceptedProtocol tests
WAHAHTTP acceptanceProtocol tests
Web PushEncrypted push-service acceptanceProtocol tests
WebhookHTTP acceptanceProtocol tests
WeComRobot response codeProtocol tests
WhapiSend acknowledgementProtocol tests
WhatsApp CloudNative message and recipient acknowledgementProtocol tests
ZulipSuccess result and message IDProtocol tests

All drivers have local tests. ntfy, Gotify and Matrix also pass real-server tests; hosted and paired-session verification remains pending for other providers. See driver configuration and delivery contracts for details and integration evidence for exact server versions.

Mail reuses your configured GoForj Mailer for SMTP, SendGrid, Resend, Mailgun, Postmark, or Amazon SES. Teams uses Workflows, LINE uses the Messaging API, and Opsgenie provides legacy integration support.

The root module uses only the standard library. Mail, APNs, SNS and Web Push are optional modules. Drivers own their configured destinations; a Message contains only content. Errors preserve cancellation and provider classifications without exposing provider response text. See delivery contracts for bounds and ownership.

Installation ​

Install the latest release:

sh
go get github.com/goforj/notification@latest

All drivers except Mail, APNs, SNS and Web Push are packages in the root module. Import them from github.com/goforj/notification/driver/<name>; they need no separate installation.

Install only the optional modules you use:

sh
# Mail
go get github.com/goforj/notification/driver/mail@latest

# Apple APNs
go get github.com/goforj/notification/driver/apns@latest

# Amazon SNS
go get github.com/goforj/notification/driver/sns@latest

# Web Push
go get github.com/goforj/notification/driver/webpush@latest

Mail borrows an application-owned *mail.Mailer and configured recipients. Mail owns sender defaults, email composition and transport. The other optional modules isolate their AWS SDK or cryptographic dependencies from the root module. See Mail integration and provider capabilities for supported operations and limits.

Runnable Examples ​

ProgramRun from the repository rootDemonstrates
Quick startgo run ./examples/quickstartA title and body through the log driver
Webhookgo run ./examples/webhookA message sent to a configured local HTTP provider
Mailcd examples/mail && go run .A real Mail Resend driver and Slack composed through Fanout against local fixtures
Provider cataloggo run ./examples/providersNative root-provider configurations and a push/chat fanout
WhatsApp templatesgo run ./examples/whatsappExplicit approved-template sends against a local fixture
APNscd examples/apns && go run .Signed alerts over real HTTP/2 and TLS
SNScd examples/sns && go run .A borrowed AWS SDK client and a native local response
Web Pushcd examples/webpush && go run .Encrypted browser push and VAPID authentication
Fakego run ./examples/fakeApplication testing through Sender
Compositiongo run ./examples/compositionFanout, conservative fallback and safe retry advice
Custom HTTP transportgo run ./examples/transportCaller-owned transport and TLS trust roots
Decoratorgo run ./examples/decoratorApplication metrics through SenderFunc
Incidentgo run ./examples/incidentStable lifecycle keys with a local PagerDuty protocol fixture
Advanced fallbackgo run ./examples/fallbackOptional recipient planning, fallback, and identity

These programs run locally without hosted-provider credentials. The test suite executes them and checks their output. Provider examples use local protocol fixtures, which verify request and response handling rather than live delivery.

API Index ​

Webhook delivery ​

The URL is driver configuration. AllowPrivate below permits the local test server; the default destination policy rejects private and special addresses.

go
provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusAccepted)
}))
defer provider.Close()

driver, err := webhook.New(webhook.Config{
	URL:          provider.URL,
	AllowPrivate: true,
})
if err != nil {
	panic(err)
}
defer driver.Close()

notifier := notification.New(driver)
err = notifier.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("message accepted")
// message accepted

Custom HTTP transport ​

Set HTTPConfig.Transport to any concurrency-safe http.RoundTripper. Drivers borrow it unchanged; the caller owns its configuration and cleanup. This example uses a local TLS server and a certificate pool named roots:

go
transport := &http.Transport{
	TLSClientConfig: &tls.Config{
		RootCAs:    roots,
		MinVersion: tls.VersionTLS12,
	},
	ForceAttemptHTTP2: true,
}
defer transport.CloseIdleConnections()

driver, err := slack.New(slack.Config{
	URL: provider.URL,
	HTTP: notification.HTTPConfig{
		Transport: transport,
	},
})
if err != nil {
	panic(err)
}
defer driver.Close()

err = driver.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("accepted through custom transport")
// accepted through custom transport

Webhook exposes the same option directly as webhook.Config.Transport. The library retains its client timeout, redirect rejection, response body bounds, and safe errors. With an injected transport, dialing, DNS, TLS, proxies, and retries belong to that transport; AllowPrivate and Resolver apply only to the default transport. See transport ownership for details.

Composition ​

Use Fanout to send through every configured destination, or Fallback to try destinations in order. Both return a Sender, borrow their configured senders, and never retry. Fanout attempts every target with at most eight concurrent calls.

Fallback advances only after permanent rejection, unauthorized access or unsupported rendering. Uncertainty and transient failures stop it to avoid duplicates. Check ErrOutcomeUnknown before deciding whether to retry: a server can fail after accepting a notification.

Use compositions directly. Wrap a custom handler with New when it needs common validation and safe errors.

go
chat := notificationfake.New()
push := notificationfake.New()
sender := notification.Fanout(chat, push)
message := notification.Message{
	Title: "Monitor down",
	Body:  "API health check failed.",
}
if err := sender.Send(context.Background(), message); err != nil {
	panic(err)
}
fmt.Println("captured targets:", len(chat.Messages())+len(push.Messages()))
// captured targets: 2

chat.Respond(notification.ErrPermanent)
backup := notification.Fallback(chat, push)
if err := backup.Send(context.Background(), message); err != nil {
	panic(err)
}
fmt.Println("backup captures:", len(push.Messages()))
// backup captures: 2

push.Respond(notification.NewDeliveryError("push", notification.Outcome{
	Status:     notification.Failed,
	RetryAfter: 30 * time.Second,
}, notification.ErrThrottled))
err := notification.New(push).Send(context.Background(), message)
var failure *notification.DeliveryError
if errors.As(err, &failure) {
	fmt.Println("retry advice:", failure.RetryAfter())
	// retry advice: 30s
}

push.Respond(notification.NewDeliveryError("push", notification.Outcome{
	Status: notification.Unknown,
}, notification.ErrRetryable))
err = notification.New(push).Send(context.Background(), message)
if errors.Is(err, notification.ErrOutcomeUnknown) {
	fmt.Println("delivery uncertain: reconcile before retrying")
	// delivery uncertain: reconcile before retrying
}

Custom senders ​

Use SenderFunc to adapt an existing service or decorate a configured sender with application metrics or tracing. Preserve the caller's context and returned error. New applies validation and safe errors around the custom handler, so invalid messages do not reach it.

go
driver := notificationfake.New()
var attempts atomic.Int64

instrumented := notification.SenderFunc(func(ctx context.Context, message notification.Message) error {
	attempts.Add(1)
	return driver.Send(ctx, message)
})
notifier := notification.New(instrumented)

err := notifier.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("attempted sends:", attempts.Load())
// attempted sends: 1

err = notifier.Send(context.Background(), notification.Message{})
fmt.Println("invalid message:", errors.Is(err, notification.ErrInvalidMessage))
// invalid message: true
fmt.Println("attempted sends:", attempts.Load())
// attempted sends: 1

Incident lifecycle ​

PagerDuty, JSM, legacy Opsgenie, SIGNL4, PagerTree and ilert additionally implement IncidentSender. Construct keys from stable scoped IDs and use the same key for trigger, acknowledge and resolve. Ordinary Send requires a fixed configured key on these drivers. JSM and Opsgenie return asynchronous acceptance, without polling for completion.

go
ctx := context.Background()
key := notification.IncidentKey("tenant:42:monitor:17")
err = driver.Trigger(ctx, notification.Incident{
	Key:      key,
	Title:    "API unavailable",
	Body:     "Health check failed.",
	Source:   "health-checks",
	Severity: notification.SeverityCritical,
})
if err != nil {
	panic(err)
}
fmt.Println("trigger accepted by local fixture")
// trigger accepted by local fixture

if err := driver.Acknowledge(ctx, key); err != nil {
	panic(err)
}
if err := driver.Resolve(ctx, key); err != nil {
	panic(err)
}
fmt.Println("acknowledge and resolve use the same stable key")
// acknowledge and resolve use the same stable key

Mail delivery ​

Reuse the application-owned GoForj Mailer and configure notification recipients once. Mail owns provider credentials, sender defaults, MIME and transport. This example runs real Resend and Slack drivers against local HTTP fixtures, then composes them through Fanout. It sends no hosted email or chat message.

go
transport, err := mailresend.New(mailresend.Config{
	APIKey:     "local-fixture-key",
	Endpoint:   provider.URL + "/email",
	HTTPClient: provider.Client(),
})
if err != nil {
	panic(err)
}
mailer := mail.New(transport, mail.WithDefaultFrom("[email protected]", "Helpdesk"))
email := notificationmail.New(mailer, "[email protected]")
chat, err := slack.New(slack.Config{
	URL: provider.URL + "/slack",
	HTTP: notification.HTTPConfig{
		AllowPrivate: true,
	},
})
if err != nil {
	panic(err)
}
defer chat.Close()
sender := notification.Fanout(email, chat)
err = sender.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("accepted email and chat:", emails.Load(), chats.Load())
// accepted email and chat: 1 1

See Mail integration for provider choices, rich email, lifecycle and verification details.

Native provider configuration ​

All providers share the same Sender interface. Configure destinations once and compose senders with Fanout or Fallback. The runnable catalog demonstrates root-provider configuration against local protocol fixtures.

go
connection := notification.HTTPConfig{
	AllowPrivate: true,
}
mobile, err := pushover.New(pushover.Config{
	BaseURL: server.URL + "/pushover",
	Token:   "fixture-application-token",
	User:    "fixture-user-key",
	HTTP:    connection,
})
if err != nil {
	panic(err)
}
defer mobile.Close()
room, err := mattermost.New(mattermost.Config{
	URL:  server.URL + "/mattermost",
	HTTP: connection,
})
if err != nil {
	panic(err)
}
defer room.Close()
sender := notification.Fanout(mobile, room)
err = sender.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("accepted through push and chat:", accepted.Load())
// accepted through push and chat: 2

Application push ​

APNs owns and refreshes its provider JWT, or borrows an explicitly configured certificate transport. SNS borrows an AWS SDK v2 publisher, preserving the SDK credential model. Web Push encrypts the standard browser subscription payload and signs VAPID authentication. These optional modules do not add dependencies to the root module.

Apple APNs ​

go
driver, err := apns.New(apns.Config{
	Key:         key,
	KeyID:       "KEY0000042",
	TeamID:      "TEAM000042",
	Topic:       "example.app",
	DeviceToken: strings.Repeat("ab", 32),
	BaseURL:     service.URL,
	HTTP: notification.HTTPConfig{
		Transport: service.Client().Transport,
	},
})
if err != nil {
	panic(err)
}
defer driver.Close()
err = driver.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("APNs accepted over HTTP/2")
// APNs accepted over HTTP/2

Amazon SNS ​

go
publisher := sns.New(sns.Options{
	Region:       "us-east-1",
	BaseEndpoint: aws.String(service.URL),
	HTTPClient:   service.Client(),
	Credentials: aws.CredentialsProviderFunc(func(context.Context) (aws.Credentials, error) {
		return aws.Credentials{
			AccessKeyID:     "fixture",
			SecretAccessKey: "local-fixture-secret",
		}, nil
	}),
})
driver, err := notificationsns.New(notificationsns.Config{
	Client:   publisher,
	TopicARN: "arn:aws:sns:us-east-1:123456789012:alerts",
})
if err != nil {
	panic(err)
}
err = driver.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("SNS accepted through the borrowed AWS client")
// SNS accepted through the borrowed AWS client

Web Push ​

go
driver, err := webpush.New(webpush.Config{
	Subscription:    subscription,
	Subscriber:      "[email protected]",
	VAPIDPrivateKey: base64.RawURLEncoding.EncodeToString(signingKey.Bytes()),
	VAPIDPublicKey:  base64.RawURLEncoding.EncodeToString(signingKey.PublicKey().Bytes()),
	TTL:             60,
	Urgency:         webpush.UrgencyHigh,
	HTTP: notification.HTTPConfig{
		Transport: service.Client().Transport,
	},
})
if err != nil {
	panic(err)
}
defer driver.Close()
err = driver.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("encrypted browser push accepted")
// encrypted browser push accepted

FCM HTTP v1 accepts a caller-supplied TokenSource function for refreshed OAuth access tokens. OneSignal and Expo submit native push requests. Acceptance means the service accepted the request or ticket; the library does not poll delivery receipts.

WhatsApp Cloud ​

Ordinary Send uses free-form text within the recipient's customer-service window. Use SendTemplate with an already approved template outside that window. Configure the Graph API version explicitly. The library does not create templates or verify service-window eligibility.

go
driver, err := whatsapp.New(whatsapp.Config{
	Token:         "local-fixture-token",
	PhoneNumberID: "123456789",
	To:            "+12125550101",
	APIVersion:    "v24.0",
	BaseURL:       service.URL,
	HTTP: notification.HTTPConfig{
		AllowPrivate: true,
	},
})
if err != nil {
	panic(err)
}
defer driver.Close()
err = driver.SendTemplate(context.Background(), whatsapp.Template{
	Name:     "ticket_updated",
	Language: "en_US",
	BodyParameters: []string{
		"T-42",
	},
})
if err != nil {
	panic(err)
}
fmt.Println("accepted WhatsApp template:", accepted.Load())
// accepted WhatsApp template: 1

Application testing ​

Application services depend on notification.Sender. The fake validates and captures messages without contacting providers. Use fake.Respond(err) to test a failure.

go
fake := notificationfake.New()
var sender notification.Sender = fake

err := sender.Send(context.Background(), notification.Message{
	Title: "Ticket updated",
	Body:  "Ticket T-42 has a new owner.",
})
if err != nil {
	panic(err)
}
fmt.Println("captured messages:", len(fake.Messages()))
// captured messages: 1

Advanced dispatch ​

Applications that need recipient lookup, preferences, localized templates, per-recipient fallback, or deduplication can use NewDispatcher. These capabilities are optional and keep their explicit delivery results. Use Fallback for ordered configured destinations; use NewDispatcher when fallback must follow application recipient policy. See advanced dispatch for the complete runnable example and migration from the earlier API.

Driver constructors ​

The API index includes every driver in the driver table. These constructor expressions are extracted from the executable programs in Runnable Examples. Their local fixture URLs, HTTP settings, credentials and borrowed clients are defined in those programs. Replace fixture values with your own configuration, and handle returned errors and resource ownership as shown in the complete examples.

notificationsns.New ​

go
notificationsns.New(notificationsns.Config{
	Client:   publisher,
	TopicARN: "arn:aws:sns:us-east-1:123456789012:alerts",
})

apns.New ​

go
apns.New(apns.Config{
	Key:         key,
	KeyID:       "KEY0000042",
	TeamID:      "TEAM000042",
	Topic:       "example.app",
	DeviceToken: strings.Repeat("ab", 32),
	BaseURL:     service.URL,
	HTTP: notification.HTTPConfig{
		Transport: service.Client().Transport,
	},
})

apprise.New ​

go
apprise.New(apprise.Config{
	URL:      baseURL + "/apprise",
	Key:      "fixture",
	Tag:      "alerts",
	Username: "fixture",
	Password: "secret",
	HTTP:     connection,
})

bark.New ​

go
bark.New(bark.Config{
	URL:       baseURL + "/bark",
	DeviceKey: "fixture",
	Group:     "alerts",
	HTTP:      connection,
})

betterstack.New ​

go
betterstack.New(betterstack.Config{
	BaseURL:        baseURL + "/betterstack",
	Token:          "fixture",
	RequesterEmail: "[email protected]",
	PolicyID:       "policy",
	TeamName:       "Helpdesk",
	Email:          true,
	HTTP:           connection,
})

clicksend.New ​

go
clicksend.New(clicksend.Config{
	BaseURL:  baseURL + "/clicksend",
	Username: "fixture",
	APIKey:   "secret",
	From:     "Helpdesk",
	To:       "+12125550101",
	HTTP:     connection,
})

dingtalk.New ​

go
dingtalk.New(dingtalk.Config{
	URL:  baseURL + "/dingtalk",
	HTTP: connection,
})

discord.New ​

go
discord.New(discord.Config{
	URL:  baseURL + "/discord",
	HTTP: connection,
})

expo.New ​

go
expo.New(expo.Config{
	BaseURL:     baseURL + "/expo",
	PushToken:   "ExpoPushToken[fixture]",
	AccessToken: "fixture",
	HTTP:        connection,
})

feishu.New ​

go
feishu.New(feishu.Config{
	URL:  baseURL + "/feishu",
	HTTP: connection,
})

fcm.New ​

go
fcm.New(fcm.Config{
	BaseURL:     baseURL + "/fcm",
	ProjectID:   "project",
	DeviceToken: "device",
	TokenSource: func(context.Context) (string, error) { return "fixture", nil },
	HTTP:        connection,
})

firehydrant.New ​

go
firehydrant.New(firehydrant.Config{
	URL:  baseURL + "/firehydrant",
	Key:  "monitor/42",
	HTTP: connection,
})

goalert.New ​

go
goalert.New(goalert.Config{
	URL:   baseURL + "/goalert",
	Token: "fixture",
	Key:   "monitor/42",
	HTTP:  connection,
})

googlechat.New ​

go
googlechat.New(googlechat.Config{
	URL:  baseURL + "/googlechat",
	HTTP: connection,
})

gotify.New ​

go
gotify.New(gotify.Config{
	URL:      baseURL + "/gotify",
	Token:    "fixture",
	Priority: 5,
	HTTP:     connection,
})

homeassistant.New ​

go
homeassistant.New(homeassistant.Config{
	URL:     baseURL + "/homeassistant",
	Token:   "fixture",
	Service: "mobile_app_phone",
	HTTP:    connection,
})

ifttt.New ​

go
ifttt.New(ifttt.Config{
	BaseURL: baseURL + "/ifttt",
	Key:     "fixture",
	Event:   "ticket_updated",
	HTTP:    connection,
})

ilert.New ​

go
ilert.New(ilert.Config{
	URL:            baseURL + "/ilert",
	IntegrationKey: "fixture",
	Key:            "monitor/42",
	HTTP:           connection,
})

incidentio.New ​

go
incidentio.New(incidentio.Config{
	BaseURL:  baseURL + "/incidentio",
	Token:    "fixture",
	SourceID: "source",
	Key:      "monitor/42",
	HTTP:     connection,
})

jsm.New ​

go
jsm.New(jsm.Config{
	BaseURL: baseURL + "/jsm",
	CloudID: "cloud",
	Email:   "[email protected]",
	Token:   "fixture",
	Key:     "monitor/42",
	HTTP:    connection,
})

join.New ​

go
join.New(join.Config{
	BaseURL:  baseURL + "/join",
	APIKey:   "fixture",
	DeviceID: "device",
	HTTP:     connection,
})

line.New ​

go
line.New(line.Config{
	BaseURL: baseURL + "/line",
	Token:   "fixture",
	To:      "U00000000000000000000000000000000",
	HTTP:    connection,
})

log.New ​

go
log.New(slog.New(slog.NewTextHandler(io.Discard, nil)))

notificationmail.New ​

go
notificationmail.New(mailer, "[email protected]")

matrix.New ​

go
matrix.New(matrix.Config{
	URL:    baseURL + "/matrix",
	Token:  "fixture",
	RoomID: "!room:example.com",
	HTTP:   connection,
})

mattermost.New ​

go
mattermost.New(mattermost.Config{
	URL:  baseURL + "/mattermost",
	HTTP: connection,
})

nextcloudtalk.New ​

go
nextcloudtalk.New(nextcloudtalk.Config{
	URL:       baseURL + "/nextcloudtalk",
	Username:  "fixture",
	Password:  "secret",
	RoomToken: "room42",
	HTTP:      connection,
})

ntfy.New ​

go
ntfy.New(ntfy.Config{
	URL:   baseURL + "/ntfy",
	Topic: "alerts",
	HTTP:  connection,
})

onesignal.New ​

go
onesignal.New(onesignal.Config{
	BaseURL:        baseURL + "/onesignal",
	AppID:          "application",
	Token:          "fixture",
	SubscriptionID: "device",
	HTTP:           connection,
})

opsgenie.New ​

go
opsgenie.New(opsgenie.Config{
	BaseURL: baseURL + "/opsgenie",
	Token:   "fixture",
	Key:     "monitor/42",
	HTTP:    connection,
})

pagerduty.New ​

go
pagerduty.New(pagerduty.Config{
	RoutingKey: strings.Repeat("a", 32),
	URL:        server.URL,
	HTTP: notification.HTTPConfig{
		AllowPrivate: true,
	},
})

pagertree.New ​

go
pagertree.New(pagertree.Config{
	URL:  baseURL + "/pagertree",
	Key:  "monitor/42",
	HTTP: connection,
})

plivo.New ​

go
plivo.New(plivo.Config{
	BaseURL:   baseURL + "/plivo",
	AuthID:    "fixture",
	AuthToken: "secret",
	From:      "+12125550100",
	To:        "+12125550101",
	HTTP:      connection,
})

pushbullet.New ​

go
pushbullet.New(pushbullet.Config{
	BaseURL:  baseURL + "/pushbullet",
	Token:    "fixture",
	DeviceID: "device",
	HTTP:     connection,
})

pushover.New ​

go
pushover.New(pushover.Config{
	BaseURL: baseURL + "/pushover",
	Token:   "fixture",
	User:    "user",
	Device:  "phone",
	HTTP:    connection,
})

rocketchat.New ​

go
rocketchat.New(rocketchat.Config{
	URL:  baseURL + "/rocketchat",
	HTTP: connection,
})

signal.New ​

go
signal.New(signal.Config{
	URL:       baseURL + "/signal",
	Number:    "+12125550100",
	Recipient: "+12125550101",
	Token:     "fixture",
	HTTP:      connection,
})

signl4.New ​

go
signl4.New(signl4.Config{
	URL:  baseURL + "/signl4",
	Key:  "monitor/42",
	HTTP: connection,
})

slack.New ​

go
slack.New(slack.Config{
	URL: provider.URL,
	HTTP: notification.HTTPConfig{
		Transport: transport,
	},
})

teams.New ​

go
teams.New(teams.Config{
	URL:  baseURL + "/teams",
	HTTP: connection,
})

telegram.New ​

go
telegram.New(telegram.Config{
	BaseURL: baseURL + "/telegram",
	Token:   "123456:fixture",
	ChatID:  "42",
	HTTP:    connection,
})

telnyx.New ​

go
telnyx.New(telnyx.Config{
	BaseURL:            baseURL + "/telnyx",
	Token:              "fixture",
	From:               "+12125550100",
	To:                 "+12125550101",
	MessagingProfileID: "profile",
	HTTP:               connection,
})

twilio.New ​

go
twilio.New(twilio.Config{
	BaseURL:    baseURL + "/twilio",
	AccountSID: "AC00000000000000000000000000000000",
	AuthToken:  "fixture",
	From:       "+12125550100",
	To:         "+12125550101",
	HTTP:       connection,
})

vonage.New ​

go
vonage.New(vonage.Config{
	BaseURL:   baseURL + "/vonage",
	APIKey:    "fixture1",
	APISecret: "secret",
	From:      "Helpdesk",
	To:        "+12125550101",
	HTTP:      connection,
})

waha.New ​

go
waha.New(waha.Config{
	URL:     baseURL + "/waha",
	APIKey:  "fixture",
	Session: "default",
	ChatID:  "[email protected]",
	HTTP:    connection,
})

webpush.New ​

go
webpush.New(webpush.Config{
	Subscription:    subscription,
	Subscriber:      "[email protected]",
	VAPIDPrivateKey: base64.RawURLEncoding.EncodeToString(signingKey.Bytes()),
	VAPIDPublicKey:  base64.RawURLEncoding.EncodeToString(signingKey.PublicKey().Bytes()),
	TTL:             60,
	Urgency:         webpush.UrgencyHigh,
	HTTP: notification.HTTPConfig{
		Transport: service.Client().Transport,
	},
})

webhook.New ​

go
webhook.New(webhook.Config{
	URL:          provider.URL,
	AllowPrivate: true,
})

wecom.New ​

go
wecom.New(wecom.Config{
	URL:  baseURL + "/wecom",
	HTTP: connection,
})

whapi.New ​

go
whapi.New(whapi.Config{
	BaseURL: baseURL + "/whapi",
	Token:   "fixture",
	To:      "12125550101",
	HTTP:    connection,
})

whatsapp.New ​

go
whatsapp.New(whatsapp.Config{
	BaseURL:       baseURL + "/whatsapp",
	Token:         "fixture",
	PhoneNumberID: "123456789",
	To:            "+12125550101",
	APIVersion:    "v24.0",
	HTTP:          connection,
})

zulip.New ​

go
zulip.New(zulip.Config{
	URL:     baseURL + "/zulip",
	Email:   "[email protected]",
	APIKey:  "fixture",
	Channel: "alerts",
	Topic:   "Tickets",
	HTTP:    connection,
})

Development ​

sh
make test
make test-race
make test-integration # Requires Docker.
make vet
make check-generated
make security

Documentation is generated by the Go tools in docs/, using the runnable examples as the source of truth. make test validates every module, executes the example programs, and enforces exact 100% library unit statement coverage. See development and release for independent module tags, delivery contracts for guarantees and limits, and the API review for the simplicity and composition decisions.

See the current release gates for completed checks and outstanding verification.

The original framework proposal records the larger roadmap. Durable Queue integration, SQL persistence, inboxes, and GoForj generation remain future work.