client.Broadcasts

Every method in this namespace: its signature, its parameters, what it returns and an example.

Methods

One message sent to everybody in one or more audiences, a personalised copy for each person, with unsubscribe handled for you.

`Broadcasts.PreviewAsync`

Count who a broadcast to some audiences would reach

audiences:read

Signature

Task<JsonObject> PreviewAsync(    IReadOnlyDictionary<string, object?> body,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns the numbers SendAsync would work from, without sending or writing anything: recipients, the people a broadcast to these audiences would reach now, unsubscribed, the contacts skipped because they have unsubscribed, and suppressed, the subscribed contacts skipped because their address is on the suppression list. A contact in several of the audiences counts once.

The count is taken at the moment of the call, so contacts who join or leave before a send change it. Only audienceIds, excludeAudienceIds and segmentId are sent, so you can pass the same object you are about to give SendAsync.

Parameters

audienceIdsIEnumerable<string>Required: 1 to 10 audience ids. One that names no audience in the workspace is a 404 audience_not_found, and All contacts, which no broadcast can go to, is a 422 audience_is_everyone.
excludeAudienceIdsIEnumerable<string>: Up to 10 audiences whose members are left out of the count, as SendAsync leaves them out.
segmentIdstring: A saved segment that narrows the count to the contacts that match it, as the send narrows the broadcast.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject with audienceIds and excludeAudienceIds as sent, recipients, unsubscribed and suppressed.

Example

var draft = new Body{    ["audienceIds"] = new[] { "aud_4c1b8e2a7d9f05c36b4e8a71", "aud_7e3d9a1c5b2f84e06d9a3c51" },    ["from"] = "Acme <[email protected]>",    ["subject"] = "The September release",    ["text"] = "Hi {{firstName|there}}, here is what changed this month.",}; var reach = await client.Broadcasts.PreviewAsync(draft); Console.WriteLine($"{reach["recipients"]} will get it, {reach["unsubscribed"]} unsubscribed, {reach["suppressed"]} suppressed"); if ((int?)reach["recipients"] > 0){    await client.Broadcasts.SendAsync(draft);}

Notes

Needs only audiences:read, so a key that cannot send can still show somebody the count.
The SDK retries it after a network failure or a retryable status, since it changes nothing.

Also available in

API: POST /broadcasts/preview
TypeScript: nextmail.broadcasts.preview()
Python: broadcasts.preview()
Ruby: broadcasts.preview
PHP: broadcasts->preview
Go: Broadcasts.Preview
Java: broadcasts().preview
CLI: openemail broadcasts preview

`Broadcasts.SendAsync`

Send one message to everybody in one or more audiences

emails:sendaudiences:read

Signature

Task<JsonObject> SendAsync(    IReadOnlyDictionary<string, object?> body,    string? idempotencyKey = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Creates a broadcast: one message sent to every contact in the audiences you name, as a separate copy for each person. Every copy has exactly one recipient and no cc or bcc, so nobody sees who else it went to, and every copy is an ordinary email with its own msg_ id, events, tracking and webhooks. Emails.ListAsync with broadcastId: lists them. Copies are not filed in the Sent folder, because the broadcast is the record.

The call returns straight away with the broadcast queued, or scheduled when you pass scheduledAt, and the sending happens in the background, 50 people at a time. Poll GetAsync to follow status and counts as it goes.

Who gets it: every contact in at least one of audienceIds, counted once however many of them hold it, except a person who has unsubscribed and an address on the suppression list. audienceIds cannot name All contacts, the built-in audience of everyone the workspace has written to, because most of them never asked for its mail: that is a 422 audience_is_everyone. A contact added to one of the audiences after this call but before the sending reaches it is included. counts.recipients is the estimate taken at the call, and PreviewAsync returns the same count without sending.

subject, html and text take merge fields, filled in from each contact: firstName, lastName, name, email and unsubscribeUrl, each written between double braces. Each takes a fallback after a bar, so {{firstName|there}} reads there for a contact with no name. The first name is the first word of the contact's name and the last name is the rest. A custom field of the contact is written {{attributes.plan}} for the key plan, takes a fallback the same way, and reads as nothing when the contact has no such field and no fallback is given. Values are escaped in html, and any other {{…}} is left as written. With template, those five values are passed as props, but only the ones the template declares, except unsubscribeUrl, which every template receives.

Every copy carries the one-click unsubscribe headers mail clients and the large mailbox providers look for. A body or a template that does not place the unsubscribeUrl merge field itself gets a short footer with the link, in English, which also names the sender and shows the postal address once marketingPostalAddress is set through Settings.UpdateAsync. Following the link unsubscribes the person from all of the workspace's marketing mail: every audience they are in shows unsubscribedAt, Suppressions.ListUnsubscribesAsync lists them, and later broadcasts and automation emails skip them, even after they are added to an audience again. Their contact and mail sent to them one message at a time are not affected.

The whole send is checked against the plan's monthly sends before anything is written. A broadcast the allowance cannot cover throws 429 send_quota_exceeded and leaves nothing behind, and each copy counts as one send.

Parameters

audienceIdsIEnumerable<string>Required: 1 to 10 audience ids such as aud_9f2c4b7e1a0d63d84c5f2e7b. A contact in several of them gets one copy. An id that names no audience in the workspace is a 404 audience_not_found and All contacts is a 422 audience_is_everyone, and either way nothing is sent.
excludeAudienceIdsIEnumerable<string>: Up to 10 audiences whose members are left out, even when they are in one of audienceIds, such as the customers who already bought. All contacts may be named here.
segmentIdstring: A saved segment, from Segments.CreateAsync, that narrows the audiences: only the contacts that match its conditions get a copy. Its conditions are read when the broadcast is sent or scheduled and kept with it. An id that names no segment is a 404 segment_not_found.
fromstring or dictionaryRequired: Sender as [email protected], Acme <[email protected]> or a dictionary with email and name. It must be an address the key may send as, otherwise 403 from_address_forbidden.
replyTostring or dictionary: Where replies go, the same for every copy.
subjectstring: Required unless a template supplies it, at most 998 characters. Takes merge fields.
htmlstring: HTML body, at most 1,000,000 characters, with merge fields. Without the unsubscribeUrl merge field in it an unsubscribe footer is added.
textstring: Plain text body, at most 1,000,000 characters, with merge fields. Without the unsubscribeUrl merge field in it an unsubscribe line is added.
templatedictionary: A stored template instead of html and text, never beside them, as a dictionary with id and optionally version, props and slots. The merge values reach it as props it declares, such as firstName and unsubscribeUrl.
trackingdictionary: Open and link tracking for every copy, as a dictionary with opens and clicks, each true or false. A field left out follows the address it is sent from when that address set it, and is on otherwise.
tagsdictionary: Up to 8 tags as a dictionary of names to values, keys of 1 to 64 letters, digits, _ or -, values up to 256 characters. Every copy carries them, plus broadcast_id, which the server adds.
utmdictionary: Campaign tags added to every http and https link in the body, with source, medium, campaign, term and content, sent as utm_source and the rest. A link that already carries one keeps its own, and the unsubscribe link never gets them.
abTestdictionary: An A/B test, with variants, 2 to 4 dictionaries that each replace the subject, or the html and or text, of the broadcast, so an empty one keeps it, testPercent (5 to 50, 20 unless set), the share of people that get a variant, metric, opens or clicks, which picks the winner, and waitMinutes (30 to 4320, 240 unless set) before it is picked. Everybody else then gets the winning variant, and a template broadcast can only vary the subject.
scheduledAtDateTimeOffset or string: A DateTimeOffset, an ISO 8601 instant or a duration such as PT2H or P1D, in the future and at most 365 days out. A DateTimeOffset goes out as an ISO 8601 instant in UTC. Left out, the sending starts straight away.
idempotencyKeystring?: Your own key, 1 to 255 characters of letters, digits, _, ., : or -. Left out, the SDK makes one for the call, so its own retries never send twice. Sending the same key again answers with the broadcast it created instead of a new one. The same key with a different body is a 422 idempotency_key_reuse.
apiKeystring?: Sends with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the broadcast as GetAsync returns it plus replayed, with id (brd_ plus 24 hex), status queued or scheduled, audienceIds, from, subject, scheduledAt, createdAt and counts, whose recipients is the estimate and whose other counts start at 0.

Example

var broadcast = await client.Broadcasts.SendAsync(new Body{    ["audienceIds"] = new[] { "aud_4c1b8e2a7d9f05c36b4e8a71" },    ["from"] = new Body { ["email"] = "[email protected]", ["name"] = "Acme" },    ["subject"] = "{{firstName|Hello}}, the September release is out",    ["html"] = "<p>Hi {{firstName|there}},</p><p>Here is what changed.</p><p><a href=\"{{unsubscribeUrl}}\">Unsubscribe</a></p>",    ["text"] = "Hi {{firstName|there}},\n\nHere is what changed.\n\nUnsubscribe: {{unsubscribeUrl}}",    ["tags"] = new Body { ["campaign"] = "release-2026-09" },    ["scheduledAt"] = DateTimeOffset.UtcNow.AddHours(2),}, idempotencyKey: "release-2026-09"); Console.WriteLine($"{broadcast["id"]} {broadcast["status"]}, about {broadcast["counts"]?["recipients"]} people");

Notes

Safe to retry. Every call carries an Idempotency-Key, yours or one the SDK makes, so a retry after a network failure answers with the broadcast the first attempt created, with replayed: true, instead of sending again. Keys are scoped to the API key or app that sent them. Reusing a key with a different body is a 422 idempotency_key_reuse.
Refusals: 422 no_recipients when the audiences are empty or everybody in them has unsubscribed or is suppressed, 422 audience_is_everyone when one of them is All contacts, 409 domain_not_sendable when the from domain cannot sign mail yet, 422 on template.* when the template does not resolve.
No attachments, cc, bcc, translation or encryption. A body from html or text and a template together are refused.
A test key (oe_test_) creates a broadcast whose copies are marked sent and delivered to nobody, like any test send.

Also available in

API: POST /broadcasts
TypeScript: nextmail.broadcasts.send()
Python: broadcasts.send()
Ruby: broadcasts.send
PHP: broadcasts->send
Go: Broadcasts.Send
Java: broadcasts().send
CLI: openemail broadcasts send

`Broadcasts.ListAsync`

List one page of broadcasts, newest first

emails:readPages through results

Signature

Task<Page> ListAsync(    string? audienceId = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one page of the broadcasts in the workspace, newest first, each with live counts. audienceId: keeps the ones that were sent to that audience, alone or beside others.

Paging is keyset: limit: takes 1 to 100 and defaults to 25, and nextCursor, the id of the last broadcast on the page, goes back as cursor: while hasMore is true. Send the same audienceId: with every page. ListAllAsync and IterateAsync do that walk for you.

The individual messages are not here. List the copies of one broadcast with Emails.ListAsync and broadcastId:.

Parameters

audienceIdstring?: Only the broadcasts that included this audience. An id that names no audience answers an empty page.
limitint?: Rows per page, a whole number from 1 to 100. The server defaults to 25.
cursorstring?: The nextCursor from the previous page, a broadcast id. One that names no broadcast in the workspace is a 400 invalid_cursor.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A Page with items, hasMore and nextCursor. Each item has id, status, audienceIds, from, subject, counts and the timestamps.

Example

var page = await client.Broadcasts.ListAsync(audienceId: "aud_4c1b8e2a7d9f05c36b4e8a71", limit: 10); foreach (var broadcast in page){    var counts = broadcast["counts"];     Console.WriteLine($"{broadcast["createdAt"]} {broadcast["subject"]} {broadcast["status"]} {counts?["sent"]}/{counts?["recipients"]}");}

Notes

A key limited to particular addresses or domains lists only the broadcasts sent from an address or domain it holds.

Also available in

API: GET /broadcasts
TypeScript: nextmail.broadcasts.list()
Python: broadcasts.list()
Ruby: broadcasts.list
PHP: broadcasts->list
Go: Broadcasts.List
Java: broadcasts().list
CLI: openemail broadcasts list

`Broadcasts.ListAllAsync`

Collect every broadcast into one object

emails:readPages through results

Signature

Task<IReadOnlyList<JsonObject>> ListAllAsync(    string? audienceId = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Follows nextCursor from page to page and returns every broadcast in the workspace, newest first, or every one sent to audienceId: when you pass it. limit sets the page size of each request, not the total.

Parameters

audienceIdstring?: Only the broadcasts that included this audience.
limitint?: Page size per request, from 1 to 100, defaulting to 25 on the server.
cursorstring?: A broadcast id to start after.
apiKeystring?: Overrides the client's API key for every page of this walk.
cancellationTokenCancellationToken: Cancels the request.

Returns

A list of JsonObject items holding every broadcast across all pages, each shaped like an item of ListAsync.

Example

var broadcasts = await client.Broadcasts.ListAllAsync(limit: 100); Console.WriteLine(broadcasts.Count);

Notes

A failure on any page throws out of the whole call.
Every row carries live counts, so collecting a long history reads the copies of every broadcast in it. Use IterateAsync to stop early.
A key limited to particular addresses or domains lists only the broadcasts sent from an address or domain it holds.

Also available in

API: GET /broadcasts
TypeScript: nextmail.broadcasts.listAll()
Python: broadcasts.list_all()
Ruby: broadcasts.list_all
PHP: broadcasts->listAll
Go: Broadcasts.ListAll
Java: broadcasts().listAll

`Broadcasts.IterateAsync`

Stream broadcasts one at a time, newest first

emails:readPages through results

Signature

IAsyncEnumerable<JsonObject> IterateAsync(    string? audienceId = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns an IAsyncEnumerable<JsonObject> that yields broadcasts one at a time, newest first, and requests the next page only once the current one is drained. Breaking out of the loop stops the requests, so this is the cheap way to find the latest broadcast that matches something the filters cannot express.

Parameters

audienceIdstring?: Only the broadcasts that included this audience.
limitint?: Page size per request, from 1 to 100, defaulting to 25 on the server.
cursorstring?: A broadcast id to start after.
apiKeystring?: Overrides the client's API key for every page of this walk.
cancellationTokenCancellationToken: Cancels the request.

Returns

An IAsyncEnumerable<JsonObject> that yields one broadcast per step.

Example

using Nextmail.Constants; await foreach (var broadcast in client.Broadcasts.IterateAsync()){    if ((string?)broadcast["status"] == BroadcastStatuses.Sending)    {        Console.WriteLine($"Still going: {broadcast["id"]}, {broadcast["counts"]?["queued"]} waiting");         break;    }}

Notes

The generator is lazy, so an abandoned loop costs only the pages you consumed.
A key limited to particular addresses or domains lists only the broadcasts sent from an address or domain it holds.

Also available in

API: GET /broadcasts
TypeScript: nextmail.broadcasts.iterate()
Python: broadcasts.iterate()
Ruby: broadcasts.iterate
PHP: broadcasts->iterate
Go: Broadcasts.Iterate
Java: broadcasts().iterate

`Broadcasts.GetAsync`

Read one broadcast and how far it has got

emails:read

Signature

Task<JsonObject> GetAsync(    string id,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one broadcast with counts read live from its copies, which makes this the call to poll while it sends.

status moves from scheduled or queued to sending and settles on sent once every copy handed over has gone out or failed. It reads sending for as long as copies are still waiting, even after the last person was reached and completedAt was set. cancelled and failed are the other two ends, and on failed lastError says why: the from address can no longer be sent from, the template stopped resolving, the plan ran out part way, the sending itself kept failing, or not one copy could be written.

counts.recipients is the estimate taken when it was created. created is the copies written, one per person reached, skipped the people passed over because their address was suppressed by then, and failedToQueue the people whose copy could not be written. queued, sending, sent, failed and cancelled count the copies by the state each one is in now.

Parameters

idstringRequired: A brd_ id from SendAsync or ListAsync.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject with id, status, mode, source, audienceIds, from, subject, counts, lastError, scheduledAt, startedAt, completedAt, cancelledAt, createdAt and updatedAt.

Example

var broadcast = await client.Broadcasts.GetAsync("brd_5a8c1e3f7b2d94a06c8e1f3b"); Console.WriteLine($"{broadcast["status"]} {broadcast["lastError"]}");

Notes

A missing broadcast throws an NextmailApiException whose IsNotFound is true, with Code broadcast_not_found. An id from another workspace is a 404 too.
For who each copy went to and what happened to it, use ListRecipientsAsync, GetRecipientAsync reads one copy with its content, and StatsAsync sums it up.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: GET /broadcasts/{id}
TypeScript: nextmail.broadcasts.get()
Python: broadcasts.get()
Ruby: broadcasts.get
PHP: broadcasts->get
Go: Broadcasts.Get
Java: broadcasts().get
CLI: openemail broadcasts get

`Broadcasts.StatsAsync`

Read how a broadcast performed

emails:read

Signature

Task<JsonObject> StatsAsync(    string id,    string? grain = null,    int? offsetMinutes = null,    int? days = null,    int? minutes = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns the totals and a series for one broadcast. totals counts copies sent, delivered, bounced, complained (reported as spam) and failed, pending for the ones still waiting, and people who opened, clicked and unsubscribed, with opens and clicks as event counts. series is sparse and oldest first: one bucket per grain in which something happened, counting each person once at the first time it happened to them, so it adds up to the totals.

Pass days: or minutes: to also read what happened lately. window then counts the copies delivered, bounced, reported as spam, opened, clicked and unsubscribed inside it, and series keeps only its buckets, while totals still covers the whole broadcast. Without either, window is null.

Parameters

idstringRequired: A brd_ id from SendAsync or ListAsync.
grainstring?: Bucket width: minute, hour or day, defaulting to hour.
offsetMinutesint?: Minutes east of UTC to cut the buckets in, from -840 to 840. Pass (int)TimeZoneInfo.Local.GetUtcOffset(DateTimeOffset.Now).TotalMinutes for the zone of the machine.
daysint?: Reads a window of this many days too, from 1 to 1095. It starts at the beginning of its first grain bucket and ends now.
minutesint?: The window in minutes, from 1 to 1576800, which wins over days when both are sent.
apiKeystring?: Overrides the client API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject with broadcastId, grain, totals, window and series, each bucket of series an object with bucket, delivered, opened, clicked and unsubscribed. window is an object with since, delivered, bounced, complained, opened, clicked and unsubscribed, or null when no window was asked for. links lists the links clicked most, clients the mail clients and countries the countries people opened it from, and abTest how each variant of an A/B test did and which one won, or null without a test.

Example

var stats = await client.Broadcasts.StatsAsync("brd_5a8c1e3f7b2d94a06c8e1f3b", grain: "day", days: 7);var sent = (double?)stats["totals"]?["sent"] ?? 0;var opened = (double?)stats["totals"]?["opened"] ?? 0; Console.WriteLine($"{(sent > 0 ? Math.Round(opened / sent * 100) : 0)}% of the people sent it opened it"); foreach (var bucket in stats["series"]?.AsArray() ?? []){    Console.WriteLine($"{bucket?["bucket"]}: {bucket?["opened"]} opened, {bucket?["clicked"]} clicked");}

Notes

Read only, so the SDK retries it after a network failure like any other read.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: GET /broadcasts/{id}/stats
TypeScript: nextmail.broadcasts.stats()
Python: broadcasts.stats()
Ruby: broadcasts.stats
PHP: broadcasts->stats
Go: Broadcasts.Stats
Java: broadcasts().stats
CLI: openemail broadcasts stats

`Broadcasts.AnalyticsAsync`

Read how broadcasts did over a time window

emails:read

Signature

Task<JsonObject> AnalyticsAsync(    IEnumerable<string>? broadcastIds = null,    int? days = null,    int? minutes = null,    string? grain = null,    int? offsetMinutes = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns the numbers behind the Analytics tab of the Broadcasts page in one request: how the live broadcasts sent inside a window did, added up in totals and cut to grain in series, and one row per broadcast in broadcasts so they can be compared.

A copy counts when it was sent inside the window, and everything that happened to it afterwards counts with it, so an open today of a copy sent last week is in a 30 day window but not in a 1 day one. Test mode broadcasts are left out. totals and series add up the broadcasts named in broadcastIds:, or every one when it is left out, while broadcasts always lists every broadcast in the window, newest first.

series is sparse and oldest first: a bucket in which nothing happened has no entry, so a chart must fill the gaps. It counts each person once, at the first time it happened to them. grain: sets the bucket width and the key shape, YYYY-MM-DD, YYYY-MM-DDTHH or YYYY-MM-DDTHH:MM, and offsetMinutes: shifts the boundaries so days break where the reader's day does. The window starts at the beginning of its oldest bucket, reported as since, and ends now, reported as until.

Parameters

broadcastIdsIEnumerable<string>?: Up to 50 broadcast ids for totals and series to add up, as a dictionary or one comma-separated string, sent comma separated. Leave it out, or pass an empty dictionary, for every broadcast in the window. An id with no copy in the window adds nothing, and more than 50 is a 422.
daysint?: Window length in days, from 1 to 1095, defaulting to 30.
minutesint?: Window length in minutes, from 1 to 1576800, which wins over days when both are sent.
grainstring?: Bucket width: minute, hour or day, defaulting to day.
offsetMinutesint?: Minutes east of UTC to cut the buckets in, from -840 to 840, defaulting to 0. Pass (int)TimeZoneInfo.Local.GetUtcOffset(DateTimeOffset.Now).TotalMinutes for the zone of the machine.
apiKeystring?: Overrides the client API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject with object set to broadcast_analytics, since, until, grain, offsetMinutes, broadcastIds, totals, series and broadcasts. totals has broadcasts and the counts the totals of StatsAsync has, each entry of series is an object with bucket, sent, delivered, opened, clicked and unsubscribed, and each entry of broadcasts has id, subject, status, sentAt and the same counts.

Example

var offsetMinutes = (int)TimeZoneInfo.Local.GetUtcOffset(DateTimeOffset.Now).TotalMinutes;var analytics = await client.Broadcasts.AnalyticsAsync(days: 90, offsetMinutes: offsetMinutes);var totals = analytics["totals"]; Console.WriteLine($"{totals?["broadcasts"]} broadcasts, {totals?["opened"]} people opened one"); foreach (var row in analytics["broadcasts"]?.AsArray() ?? []){    Console.WriteLine($"{row?["subject"]}: {row?["sent"]} sent, {row?["opened"]} opened, {row?["clicked"]} clicked");}

Notes

Read only, so the SDK retries it after a network failure like any other read.
opened, clicked and unsubscribed count people, while opens and clicks count events.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds, and the rest are left out as if they did not exist.

Also available in

API: GET /broadcasts/analytics
TypeScript: nextmail.broadcasts.analytics()
Python: broadcasts.analytics()
Ruby: broadcasts.analytics
PHP: broadcasts->analytics
Go: Broadcasts.Analytics
Java: broadcasts().analytics
CLI: openemail broadcasts analytics

`Broadcasts.ListRecipientsAsync`

List who a broadcast went to and what happened to each copy

emails:readPages through results

Signature

Task<Page> ListRecipientsAsync(    string id,    string? filter = null,    string? q = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one page of the people a broadcast went to, one row per copy, sorted by address. Each row says the copy's status, when it was sent and delivered, whether it bounced or was reported as spam, how often it was opened and clicked, and whether the person unsubscribed from one of the broadcast's audiences after it went out.

Opens and clicks leave out image proxies and link scanners, and stay 0 when the broadcast went out with tracking off. emailId is the copy's msg_ id, which GetRecipientAsync reads with its content and Emails.GetAsync reads as a sent email.

Parameters

idstringRequired: A brd_ id from SendAsync or ListAsync.
filterstring?: Keeps one group: pending, sent, delivered, opened, not_opened (sent and never opened), clicked, bounced, complained, failed (failed or cancelled) or unsubscribed. Nextmail\Constants\BroadcastRecipientFilters names them.
qstring?: Searches the address and the name, ignoring case.
limitint?: Page size, from 1 to 200. The server defaults to 50.
cursorstring?: The nextCursor of the previous page. Send the same filter: and q: with it.
apiKeystring?: Overrides the client API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A Page with items, hasMore and nextCursor. Each item has emailId, contactId, email, name, status, sentAt, deliveredAt, bouncedAt, complainedAt, failure, opens, firstOpenAt, clicks, firstClickAt and unsubscribedAt.

Example

using Nextmail.Constants; var page = await client.Broadcasts.ListRecipientsAsync("brd_5a8c1e3f7b2d94a06c8e1f3b", filter: BroadcastRecipientFilters.Bounced); foreach (var copy in page){    Console.WriteLine($"{copy["email"]} bounced at {copy["bouncedAt"]}");}

Notes

A missing broadcast throws an NextmailApiException with Code broadcast_not_found.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: GET /broadcasts/{id}/recipients
TypeScript: nextmail.broadcasts.listRecipients()
Python: broadcasts.list_recipients()
Ruby: broadcasts.list_recipients
PHP: broadcasts->listRecipients
Go: Broadcasts.ListRecipients
Java: broadcasts().listRecipients
CLI: openemail broadcasts list-recipients

`Broadcasts.ListAllRecipientsAsync`

Collect everybody a broadcast went to into one object

emails:readPages through results

Signature

Task<IReadOnlyList<JsonObject>> ListAllRecipientsAsync(    string id,    string? filter = null,    string? q = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Walks every page of ListRecipientsAsync and returns every copy of the broadcast, sorted by address. One request per page, with the same filter: and q: on each.

Parameters

idstringRequired: A brd_ id from SendAsync or ListAsync.
filterstring?: Keeps one group: pending, sent, delivered, opened, not_opened (sent and never opened), clicked, bounced, complained, failed (failed or cancelled) or unsubscribed. Nextmail\Constants\BroadcastRecipientFilters names them.
qstring?: Searches the address and the name, ignoring case.
limitint?: Page size for each request, from 1 to 200. The server defaults to 50.
cursorstring?: Starts the walk after this cursor instead of the first page.
apiKeystring?: Overrides the client API key for every page of this walk.
cancellationTokenCancellationToken: Cancels the request.

Returns

A list of JsonObject items holding every copy that matches, each shaped like an item of ListRecipientsAsync.

Example

using Nextmail.Constants; var unopened = await client.Broadcasts.ListAllRecipientsAsync("brd_5a8c1e3f7b2d94a06c8e1f3b", filter: BroadcastRecipientFilters.NotOpened); Console.WriteLine($"{string.Join(Environment.NewLine, unopened.Select(row => row?["email"]))}");

Notes

If any page fails the call throws and the rows already fetched are discarded.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: GET /broadcasts/{id}/recipients
TypeScript: nextmail.broadcasts.listAllRecipients()
Python: broadcasts.list_all_recipients()
Ruby: broadcasts.list_all_recipients
PHP: broadcasts->listAllRecipients
Go: Broadcasts.ListAllRecipients
Java: broadcasts().listAllRecipients

`Broadcasts.IterateRecipientsAsync`

Walk everybody a broadcast went to, one copy at a time

emails:readPages through results

Signature

IAsyncEnumerable<JsonObject> IterateRecipientsAsync(    string id,    string? filter = null,    string? q = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns an IAsyncEnumerable<JsonObject> that yields every copy of the broadcast one at a time, fetching the next page only when the loop asks for it, sorted by address. Breaking out of the loop stops the requests.

Parameters

idstringRequired: A brd_ id from SendAsync or ListAsync.
filterstring?: Keeps one group: pending, sent, delivered, opened, not_opened (sent and never opened), clicked, bounced, complained, failed (failed or cancelled) or unsubscribed. Nextmail\Constants\BroadcastRecipientFilters names them.
qstring?: Searches the address and the name, ignoring case.
limitint?: Page size for each request, from 1 to 200. The server defaults to 50.
cursorstring?: Starts after this cursor instead of the first page.
apiKeystring?: Overrides the client API key for every page of this walk.
cancellationTokenCancellationToken: Cancels the request.

Returns

An IAsyncEnumerable<JsonObject> that yields one copy per step, each shaped like an item of ListRecipientsAsync.

Example

using Nextmail.Constants; var copies = client.Broadcasts.IterateRecipientsAsync("brd_5a8c1e3f7b2d94a06c8e1f3b", filter: BroadcastRecipientFilters.Clicked); await foreach (var copy in copies){    Console.WriteLine($"{copy["email"]} clicked {copy["clicks"]} times");}

Notes

Memory stays flat however large the broadcast, because only one page is held at a time.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: GET /broadcasts/{id}/recipients
TypeScript: nextmail.broadcasts.iterateRecipients()
Python: broadcasts.iterate_recipients()
Ruby: broadcasts.iterate_recipients
PHP: broadcasts->iterateRecipients
Go: Broadcasts.IterateRecipients
Java: broadcasts().iterateRecipients

`Broadcasts.GetRecipientAsync`

Read one person's copy of a broadcast

emails:read

Signature

Task<JsonObject> GetRecipientAsync(    string id,    string emailId,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one copy: the same row ListRecipientsAsync gives, plus the subject, html and text exactly as that person received them, with the merge fields filled in and their own unsubscribe link. The HTML is from before open and click tracking was added.

Parameters

idstringRequired: A brd_ id from SendAsync or ListAsync.
emailIdstringRequired: The emailId of the copy, from ListRecipientsAsync.
apiKeystring?: Overrides the client API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject with emailId, contactId, email, name, status, sentAt, deliveredAt, bouncedAt, complainedAt, failure, opens, firstOpenAt, clicks, firstClickAt and unsubscribedAt, plus subject, html and text.

Example

var copy = await client.Broadcasts.GetRecipientAsync("brd_5a8c1e3f7b2d94a06c8e1f3b", "msg_01dad25067bc4dac966d515d"); Console.WriteLine($"{copy["subject"]}, delivered {copy["deliveredAt"]?.ToString() ?? "not yet"}");Console.WriteLine($"{copy["text"]}");

Notes

An emailId that is not a copy of this broadcast throws an NextmailApiException with Code recipient_not_found.
A key limited to particular addresses or domains reads only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: GET /broadcasts/{id}/recipients/{emailId}
TypeScript: nextmail.broadcasts.getRecipient()
Python: broadcasts.get_recipient()
Ruby: broadcasts.get_recipient
PHP: broadcasts->getRecipient
Go: Broadcasts.GetRecipient
Java: broadcasts().getRecipient
CLI: openemail broadcasts get-recipient

`Broadcasts.CancelAsync`

Stop a broadcast that is scheduled, queued or still sending

emails:send

Signature

Task<JsonObject> CancelAsync(    string id,    string? apiKey = null,    CancellationToken cancellationToken = default)

Stops a broadcast that is scheduled, queued or sending, including one that has reached everybody while some copies are still waiting to go. Nobody else is added, and every copy still waiting is cancelled. A copy already being handed over finishes, and copies that have gone cannot be recalled, so counts.sent keeps them and counts.cancelled shows what was stopped.

Once every copy has gone out there is nothing left to stop, and the call throws 409 broadcast_not_cancellable. A failed broadcast with copies still waiting can be cancelled to stop them, and one with nothing waiting is refused the same way. Cancelling a broadcast that is already cancelled returns it as it stands, so the call is safe to repeat, and the SDK retries it after a network failure.

Parameters

idstringRequired: The brd_ id to cancel.
apiKeystring?: Cancels with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the broadcast as GetAsync returns it in its new state: status cancelled with cancelledAt set and the copies counted by where each one ended up.

Example

var scheduled = await client.Broadcasts.SendAsync(new Body{    ["audienceIds"] = new[] { "aud_4c1b8e2a7d9f05c36b4e8a71" },    ["from"] = "[email protected]",    ["subject"] = "Doors open on Friday",    ["text"] = "Hi {{firstName|there}}, doors open at nine.",    ["scheduledAt"] = "P1D",}); var cancelled = await client.Broadcasts.CancelAsync(scheduled["id"]!.GetValue<string>()); Console.WriteLine($"{cancelled["status"]}, {cancelled["counts"]?["cancelled"]} copies stopped");

Notes

Cancelling a scheduled broadcast before scheduledAt sends nothing at all.
A cancelled broadcast stays cancelled. There is no resume, so send again to the audiences that still need it.
A key limited to particular addresses or domains cancels only broadcasts sent from an address or domain it holds. Any other id throws an NextmailApiException with Code broadcast_not_found, as if the broadcast did not exist.

Also available in

API: POST /broadcasts/{id}/cancel
TypeScript: nextmail.broadcasts.cancel()
Python: broadcasts.cancel()
Ruby: broadcasts.cancel
PHP: broadcasts->cancel
Go: Broadcasts.Cancel
Java: broadcasts().cancel
CLI: openemail broadcasts cancel

`Broadcasts.CreateDraftAsync`

Save a broadcast as a draft without sending it

emails:sendaudiences:read

Signature

Task<JsonObject> CreateDraftAsync(    IReadOnlyDictionary<string, object?> body,    string? apiKey = null,    CancellationToken cancellationToken = default)

Saves a broadcast with status draft. Nothing is sent, nothing counts against the plan and the audiences may still be empty, so a draft can be written over several sittings. UpdateAsync changes it, SendDraftAsync sends it or schedules it, and GetAsync returns what it holds in content.

The body takes the fields SendAsync takes, except scheduledAt, which belongs to SendDraftAsync. Only from is required. The sender, the audiences and a template are checked as they are saved.

Parameters

fromstring or dictionaryRequired: Sender as [email protected] or Acme <[email protected]>, or a dictionary with email and name. It must be an address the key may send as, otherwise 403 from_address_forbidden.
audienceIdsIEnumerable<string>: Up to 10 audience ids. Left out or empty, the draft has no audience yet and SendDraftAsync refuses it until UpdateAsync gives it one.
excludeAudienceIdsIEnumerable<string>: Up to 10 audiences whose members are left out, even when they are in one of audienceIds.
segmentIdstring: A saved segment that narrows the audiences when the draft is sent. It has to exist when the draft is saved and again when it is sent.
replyTostring or dictionary: Where replies go, the same for every copy.
subjectstring: At most 998 characters, with merge fields. Needed before sending unless a template supplies it.
htmlstring: HTML body, at most 1,000,000 characters, with merge fields.
textstring: Plain text body, at most 1,000,000 characters, with merge fields.
templatedictionary: A stored template instead of html and text, with id and, optionally, version, props and slots.
trackingdictionary: Open and link tracking for every copy, with opens and clicks.
tagsdictionary: Up to 8 tags every copy carries.
utmdictionary: Campaign tags added to every http and https link in the body, with source, medium, campaign, term and content, sent as utm_source and the rest. A link that already carries one keeps its own, and the unsubscribe link never gets them.
abTestdictionary: An A/B test, as SendAsync takes it.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the broadcast with status draft, counts at 0 and the saved fields in content.

Example

var draft = await client.Broadcasts.CreateDraftAsync(new Body{    ["from"] = "Acme <[email protected]>",    ["audienceIds"] = new[] { "aud_4c1b8e2a7d9f05c36b4e8a71" },    ["subject"] = "The October release",    ["text"] = "Hi {{firstName|there}}, here is what changed this month.",    ["utm"] = new Body { ["source"] = "newsletter", ["medium"] = "email", ["campaign"] = "october-release" },}); Console.WriteLine($"{draft["id"]} {draft["status"]}");

Notes

A draft is listed by ListAsync beside the broadcasts that went out, with status draft.
Refusals are 404 audience_not_found, 422 audience_is_everyone when audienceIds names All contacts, 403 from_address_forbidden, and 422 on template.* when the template does not resolve.

Also available in

API: POST /broadcasts/drafts
TypeScript: nextmail.broadcasts.createDraft()
Python: broadcasts.create_draft()
Ruby: broadcasts.create_draft
PHP: broadcasts->createDraft
Go: Broadcasts.CreateDraft
Java: broadcasts().createDraft
CLI: openemail broadcasts create-draft

`Broadcasts.UpdateAsync`

Change a draft, or a scheduled broadcast before it starts

emails:sendaudiences:read

Signature

Task<JsonObject> UpdateAsync(    string id,    IReadOnlyDictionary<string, object?> patch,    string? apiKey = null,    CancellationToken cancellationToken = default)

A partial update: a field you leave out keeps what it holds, and null clears replyTo, html, text, template or utm. Sending any of html, text or template replaces the body as a whole.

A draft takes every change and stays a draft. A scheduled broadcast takes changes until its sending starts, and each change is checked the way SendAsync checks a new one, so counts.recipients is counted again. scheduledAt moves a scheduled broadcast to another time. Once a broadcast is queued, sending or finished, the call throws 409 broadcast_not_editable.

Parameters

idstringRequired: The brd_ id of a draft or of a scheduled broadcast.
audienceIdsIEnumerable<string>: The new audiences, replacing the old list, up to 10.
excludeAudienceIdsIEnumerable<string>: The new list of audiences whose members are left out.
segmentIdstring or null: A saved segment that narrows the audiences. Null takes it away.
fromstring or dictionary: A new sender the key may send as.
replyTostring, dictionary or null: Where replies go. null takes it away.
subjectstring: A new subject, with merge fields.
htmlstring?: A new HTML body.
textstring?: A new plain text body.
templatedictionary or null: A stored template instead of html and text.
trackingdictionary: Open and link tracking for every copy.
tagsdictionary: The new tags, replacing the old ones.
utmdictionary or null: New campaign tags for the links. null takes them away.
abTestdictionary or null: A new A/B test, as SendAsync takes it. null takes it away.
scheduledAtDateTimeOffset or string: A new start for a scheduled broadcast: an ISO 8601 instant or a duration such as PT2H. A draft refuses it with 422 invalid_parameter, since SendDraftAsync schedules a draft.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the broadcast as it stands after the change, with content.

Example

var draft = await client.Broadcasts.CreateDraftAsync(new Body{    ["from"] = "[email protected]",    ["subject"] = "Draft",}); var updated = await client.Broadcasts.UpdateAsync(draft["id"]!.GetValue<string>(), new Body{    ["audienceIds"] = new[] { "aud_4c1b8e2a7d9f05c36b4e8a71" },    ["subject"] = "Doors open on Friday",    ["text"] = "Hi {{firstName|there}}, doors open at nine.",}); Console.WriteLine($"{updated["status"]} {updated["subject"]}");

Notes

A key limited to particular addresses or domains changes only broadcasts sent from an address or domain it holds. Any other id throws broadcast_not_found.
Changing a scheduled broadcast can fail the way SendAsync fails: 422 no_recipients, 429 send_quota_exceeded, 409 stream_paused.

Also available in

API: PATCH /broadcasts/{id}
TypeScript: nextmail.broadcasts.update()
Python: broadcasts.update()
Ruby: broadcasts.update
PHP: broadcasts->update
Go: Broadcasts.Update
Java: broadcasts().update
CLI: openemail broadcasts update

`Broadcasts.SendDraftAsync`

Send a draft now, or schedule it

emails:sendaudiences:read

Signature

Task<JsonObject> SendDraftAsync(    string id,    IReadOnlyDictionary<string, object?>? body = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Turns a draft into a broadcast that goes out: queued straight away, or scheduled when you pass scheduledAt. The draft is checked the way SendAsync checks a new broadcast, so it needs an audience, a body, a subject or a template that supplies one, somebody to reach, and room in the plan for every copy.

A broadcast that is not a draft throws 409 broadcast_not_draft, so calling it twice never sends twice.

Parameters

idstringRequired: The brd_ id of the draft.
scheduledAtDateTimeOffset or string: An ISO 8601 instant or a duration such as PT2H, in the future and at most 365 days out. Left out, the sending starts straight away.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the broadcast with status queued or scheduled and counts.recipients estimated at the call.

Example

var draft = await client.Broadcasts.CreateDraftAsync(new Body{    ["from"] = "Acme <[email protected]>",    ["audienceIds"] = new[] { "aud_4c1b8e2a7d9f05c36b4e8a71" },    ["subject"] = "Doors open on Friday",    ["text"] = "Hi {{firstName|there}}, doors open at nine.",}); var sent = await client.Broadcasts.SendDraftAsync(draft["id"]!.GetValue<string>(), new Body{    ["scheduledAt"] = "PT2H",}); Console.WriteLine($"{sent["status"]} {sent["scheduledAt"]}");

Notes

Refusals are 409 broadcast_not_draft, 422 no_recipients, 422 invalid_parameter when the draft has no body or no subject, 429 send_quota_exceeded, and 409 stream_paused while the broadcast lane of the workspace is paused.
The SDK does not retry it after a network failure. Read the broadcast with GetAsync before calling again.

Also available in

API: POST /broadcasts/{id}/send
TypeScript: nextmail.broadcasts.sendDraft()
Python: broadcasts.send_draft()
Ruby: broadcasts.send_draft
PHP: broadcasts->sendDraft
Go: Broadcasts.SendDraft
Java: broadcasts().sendDraft
CLI: openemail broadcasts send-draft

`Broadcasts.DuplicateAsync`

Copy a broadcast into a new draft

emails:sendaudiences:read

Signature

Task<JsonObject> DuplicateAsync(    string id,    string? apiKey = null,    CancellationToken cancellationToken = default)

Makes a new draft from any broadcast, with the same sender, audiences, left-out audiences, subject, body or template, tracking, tags and campaign tags. The time it was scheduled for is not copied. The original is not changed, and nothing is sent until SendDraftAsync.

Parameters

idstringRequired: The brd_ id to copy.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the new draft with its own brd_ id, status draft and content.

Example

var copy = await client.Broadcasts.DuplicateAsync("brd_5e8a2c1f9b3d74e06a5c2f81"); Console.WriteLine($"{copy["id"]} {copy["status"]}");

Notes

The sender, the audiences and the template are checked again as the copy is saved, so a copy of an old broadcast can fail with 403 from_address_forbidden or 404 audience_not_found.

Also available in

API: POST /broadcasts/{id}/duplicate
TypeScript: nextmail.broadcasts.duplicate()
Python: broadcasts.duplicate()
Ruby: broadcasts.duplicate
PHP: broadcasts->duplicate
Go: Broadcasts.Duplicate
Java: broadcasts().duplicate
CLI: openemail broadcasts duplicate

`Broadcasts.ResendAsync`

Send a broadcast again to the people who did not open it

emails:sendaudiences:read

Signature

Task<JsonObject> ResendAsync(    string id,    IReadOnlyDictionary<string, object?>? body = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Creates a new broadcast with the same content for the people the first one reached and who have not opened it, optionally under a new subject. Somebody who has unsubscribed since, or whose address is now suppressed, is skipped. The new broadcast carries content.resendOf, and counts against the plan like any send.

The first broadcast has to have finished going out and to have tracked opens. Otherwise the call throws 409 resend_unavailable.

Parameters

idstringRequired: The brd_ id of the broadcast that went out.
subjectstring: A new subject for the second try, with merge fields. Left out, the first subject is used.
scheduledAtDateTimeOffset or string: When to start, in the future and at most 365 days out. Left out, the sending starts straight away.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject, the new broadcast, queued or scheduled, with counts.recipients holding the people who had not opened.

Example

var second = await client.Broadcasts.ResendAsync("brd_5e8a2c1f9b3d74e06a5c2f81", new Body{    ["subject"] = "In case you missed it: doors open on Friday",    ["scheduledAt"] = "P2D",}); Console.WriteLine($"{second["id"]} {second["counts"]?["recipients"]}");

Notes

Opens are counted from the tracking pixel, so somebody whose mail app blocks images can look like they never opened. Give a second try some days, and do not send it more than once.
Refusals are 409 resend_unavailable, 422 no_recipients when everybody opened it, 429 send_quota_exceeded, and 409 stream_paused.

Also available in

API: POST /broadcasts/{id}/resend
TypeScript: nextmail.broadcasts.resend()
Python: broadcasts.resend()
Ruby: broadcasts.resend
PHP: broadcasts->resend
Go: Broadcasts.Resend
Java: broadcasts().resend
CLI: openemail broadcasts resend

`Broadcasts.SendTestAsync`

Send a test copy of a broadcast to yourself or a few people

emails:send

Signature

Task<JsonObject> SendTestAsync(    IReadOnlyDictionary<string, object?> body,    string? apiKey = null,    CancellationToken cancellationToken = default)

Sends one copy of a broadcast to up to five addresses, to read it before it goes to an audience. It goes to the account address of the person the key or app acts for, the workspace owner for an API key, unless to names others. The merge fields are filled from the contact that has the address when there is one and from a sample name otherwise, the subject starts with [Test], the unsubscribe footer is added as it would be and its link does nothing. Opens and clicks are not tracked, and utm is applied to the links.

No broadcast is created and nobody joins an audience. Each copy counts as one send.

Parameters

fromstring or dictionaryRequired: The sender, an address the key may send as.
toIEnumerable<string>: 1 to 5 addresses. Left out, the test goes to the account address of the person the key or app acts for.
replyTostring or dictionary: Where replies go.
subjectstring: Required unless a template supplies it, with merge fields.
htmlstring: HTML body with merge fields.
textstring: Plain text body with merge fields.
templatedictionary: A stored template instead of html and text.
utmdictionary: Campaign tags added to the links, as the broadcast would add them.
apiKeystring?: Overrides the client's API key for this call only.
cancellationTokenCancellationToken: Cancels the request.

Returns

A JsonObject with the msg_ id of each copy in emailIds and the addresses in to.

Example

var test = await client.Broadcasts.SendTestAsync(new Body{    ["from"] = "Acme <[email protected]>",    ["to"] = new[] { "[email protected]" },    ["subject"] = "{{firstName|Hello}}, doors open on Friday",    ["html"] = "<p>Hi {{firstName|there}}, doors open at nine.</p>",}); Console.WriteLine($"{test["emailIds"]} {test["to"]}");

Notes

The SDK does not retry it, since a retry would send the test again.

Also available in

API: POST /broadcasts/test
TypeScript: nextmail.broadcasts.sendTest()
Python: broadcasts.send_test()
Ruby: broadcasts.send_test
PHP: broadcasts->sendTest
Go: Broadcasts.SendTest
Java: broadcasts().sendTest
CLI: openemail broadcasts send-test