client.Tracking

Çdo metodë në këtë hapësirë emrash: nënshkrimi, parametrat, çfarë kthen dhe një shembull.

Metodat

Opens and clicks on tracked messages, one message at a time or rolled up.

`Tracking.ListAsync`

List one page of tracked messages in a time window

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

Task<Page> ListAsync(    bool? opened = null,    bool? clicked = null,    int? days = null,    int? minutes = null,    string? grain = null,    string? address = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one page of the messages the workspace tracked and sent in the window, newest first, each as a full engagement report with its recipients and links. It covers the whole mailbox, not only mail sent through this API: messages from the composer, the MCP tools and the assistant appear too, with sendId null where no send record exists. A report built off Emails.ListAsync would describe the API rather than the mailbox.

Messages that carried no pixel and no rewritten link are absent entirely and never appear as a zero. opened: false therefore means tracked and not opened, and clicked narrows the same way. Both filters work on counted opens and clicks, so a message fetched only by Apple Mail Privacy Protection or a link scanner still counts as unopened.

The window defaults to 30 days. minutes wins over days when both are set, and the start of the window is floored to the grain in UTC, so days: 7 covers today plus the six whole days before it. Paging is keyset: nextCursor is the tmsg_ id of the last report on the page, and passing it back as cursor with the same filters continues strictly after it, so every tracked message in the window is reachable. ListAllAsync and IterateAsync do that walk for you.

Parametrat

openedbool?: Leave it out for both. true keeps opened messages and false keeps tracked messages nobody opened.
clickedbool?: Leave it out for both. true keeps messages with a counted click and false keeps those without.
daysint?: Window length in days, a whole number from 1 to 365, defaulting to 30.
minutesint?: Window length in minutes, from 1 to 527040. Takes precedence over days.
grainstring?: minute, hour or day, defaulting to day. It only floors the window start so this list matches GetStatsAsync read at the same grain, and shapes nothing in the response.
addressstring?: Keeps only the messages sent from this address, the address filter of the tracking page. One the key does not reach returns nothing rather than failing.
limitint?: Reports per page, from 1 to 200, defaulting to 50.
cursorstring?: The nextCursor from the previous page, a tmsg_ id. One that names no tracked message in the workspace is a 400 invalid_cursor.
apiKeystring?: Lists with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A Page with items, hasMore and nextCursor. Each item has id, sendId, subject, from, source, sentAt, opens, clicks, opened, clicked, attributable, the counted and raw open and click counts, recipients and links.

Shembull

var page = await client.Tracking.ListAsync(opened: false, days: 7, limit: 200); foreach (var message in page){    Console.WriteLine($"{message["sentAt"]} {message["subject"]}");} if (page.HasMore){    var next = await client.Tracking.ListAsync(opened: false, days: 7, cursor: page.NextCursor);     Console.WriteLine($"The next page starts with {next.Items[0]?["subject"]?.ToString() ?? "nothing"}");}

Shënime

A window shorter than a day needs a finer grain. minutes: 60 at the default day grain is rounded to one bucket and starts at midnight UTC.
A key with an address allowlist sees only messages sent from those addresses.
Only messages that were actually sent are listed, so a scheduled message that has not gone yet is absent even if tracking was requested.

E disponueshme edhe në

API: GET /tracking
TypeScript: tracking.list()
Python: tracking.list()
Ruby: tracking.list
PHP: tracking->list
Go: Tracking.List
Java: tracking().list
CLI: openemail tracking list

`Tracking.ListAllAsync`

Collect every tracked message in a window into one object

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

Task<IReadOnlyList<JsonObject>> ListAllAsync(    bool? opened = null,    bool? clicked = null,    int? days = null,    int? minutes = null,    string? grain = null,    string? address = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Follows nextCursor from page to page and returns once the last page has been read, with every tracked message in the window in one object, newest first. It takes the same filters as ListAsync and returns the same full engagement reports.

Everything is held in memory before the call returns. Narrow the window or the filters, or switch to IterateAsync when you want to stop early. limit sets the page size of each underlying request, not the total.

Parametrat

openedbool?: Leave it out for both. true keeps opened messages and false keeps tracked messages nobody opened.
clickedbool?: Leave it out for both. true keeps messages with a counted click and false keeps those without.
daysint?: Window length in days, a whole number from 1 to 365, defaulting to 30.
minutesint?: Window length in minutes, from 1 to 527040. Takes precedence over days.
grainstring?: minute, hour or day, defaulting to day. It only floors the window start.
addressstring?: Keeps only the messages sent from this address, the address filter of the tracking page. One the key does not reach returns nothing rather than failing.
limitint?: Page size per request, from 1 to 200, defaulting to 50 on the server.
cursorstring?: A tmsg_ id to start after, skipping everything newer.
apiKeystring?: Lists with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A list of JsonObject items holding every report across all pages.

Shembull

var unopened = await client.Tracking.ListAllAsync(opened: false, days: 30, limit: 200); foreach (var message in unopened){    Console.WriteLine($"{message["sentAt"]} {message["subject"]}");}

Shënime

A failure on any page throws out of the whole call, and the reports already fetched are discarded.
A key with an address allowlist sees only messages sent from those addresses, on every page.

E disponueshme edhe në

API: GET /tracking
TypeScript: tracking.listAll()
Python: tracking.list_all()
Ruby: tracking.list_all
PHP: tracking->listAll
Go: Tracking.ListAll
Java: tracking().listAll

`Tracking.IterateAsync`

Stream tracked messages one at a time across pages

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

IAsyncEnumerable<JsonObject> IterateAsync(    bool? opened = null,    bool? clicked = null,    int? days = null,    int? minutes = null,    string? grain = null,    string? address = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns an IAsyncEnumerable<JsonObject> that yields tracked messages individually, newest first, and requests the next page only once the current one is drained. Nothing is fetched until you start consuming it, and breaking out of the loop stops the requests.

The walk is keyset based, following nextCursor from page to page, so a message tracked while you iterate lands ahead of where you started and is never yielded, and nothing already yielded comes round again.

Parametrat

openedbool?: Leave it out for both. true keeps opened messages and false keeps tracked messages nobody opened.
clickedbool?: Leave it out for both. true keeps messages with a counted click and false keeps those without.
daysint?: Window length in days, a whole number from 1 to 365, defaulting to 30.
minutesint?: Window length in minutes, from 1 to 527040. Takes precedence over days.
grainstring?: minute, hour or day, defaulting to day. It only floors the window start.
addressstring?: Keeps only the messages sent from this address, the address filter of the tracking page. One the key does not reach returns nothing rather than failing.
limitint?: Page size per request, from 1 to 200, defaulting to 50 on the server.
cursorstring?: A tmsg_ id to start after, skipping everything newer.
apiKeystring?: Lists with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

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

Shembull

await foreach (var message in client.Tracking.IterateAsync(clicked: true, days: 90)){    Console.WriteLine(message["id"]);}

Shënime

The generator is lazy, so an abandoned loop costs only the pages you consumed.

E disponueshme edhe në

API: GET /tracking
TypeScript: tracking.iterate()
Python: tracking.iterate()
Ruby: tracking.iterate
PHP: tracking->iterate
Go: Tracking.Iterate
Java: tracking().iterate

`Tracking.GetStatsAsync`

Summarise engagement across a time window

emails:read

Nënshkrimi

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

Returns the numbers behind an engagement panel in one request: how many messages were tracked, opened and clicked, the open and click rates, hit totals, a time series, the top links, mail clients and countries. It covers every tracked message sent from the mailbox in the window, whichever surface sent it.

Rates and totals count different things, and mixing them is how open rates above 100% get published. opened and clicked count distinct messages. totalOpens and totalClicks count hits. openRate is a percentage of trackedForOpens, the messages that actually carried a pixel, and clickRate is a percentage of trackedForClicks, the messages that had a link to rewrite, which is usually far fewer than tracked because most replies contain no links.

byDay is sparse: a bucket in which nothing was sent has no entry, so a chart must fill the gaps. grain sets the bucket width and the key shape, YYYY-MM-DD, YYYY-MM-DDTHH or YYYY-MM-DDTHH:MM, and offsetMinutes shifts bucket boundaries so days break where the reader's day does. The window starts at the beginning of the oldest bucket, so that bucket is whole, and ends now, so the newest is partial.

Parametrat

daysint?: Window length in days, from 1 to 365, defaulting to 30.
minutesint?: Window length in minutes, from 1 to 527040. Takes precedence over days, and only useful below a day with a finer grain.
grainstring?: Bucket width for byDay: minute, hour or day, defaulting to day.
offsetMinutesint?: Minutes east of UTC to bucket in, from -840 to 840, defaulting to 0. Pass (int)TimeZoneInfo.Local.GetUtcOffset(DateTimeOffset.Now).TotalMinutes for the zone of the machine.
addressstring?: Counts only the messages sent from this address, the address filter of the tracking page. One the key does not reach counts nothing rather than failing.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A JsonObject with tracked, trackedForOpens, trackedForClicks, opened, clicked, openRate, clickRate, totalOpens, totalClicks, machineOpens, medianTimeToOpenSeconds (null when nothing was opened), byDay, topLinks, clients and countries.

Shembull

var offsetMinutes = (int)TimeZoneInfo.Local.GetUtcOffset(DateTimeOffset.Now).TotalMinutes;var stats = await client.Tracking.GetStatsAsync(days: 7, grain: "day", offsetMinutes: offsetMinutes); Console.WriteLine($"{stats["openRate"]}% of {stats["trackedForOpens"]} messages opened"); foreach (var bucket in stats["byDay"]?.AsArray() ?? []){    Console.WriteLine($"{bucket?["day"]}: {bucket?["sent"]} sent, {bucket?["opened"]} opened");}

Shënime

openRate and clickRate are percentages rounded to one decimal place, such as 42.5, not fractions between 0 and 1.
machineOpens, clients and countries are counted from individual hit records rather than from the counters on the per-message report.
A key with an address allowlist gets figures for mail sent from those addresses only, not the whole workspace.
topLinks holds at most 10 links that were clicked at least once, while clients and countries hold at most 8 each.

E disponueshme edhe në

API: GET /tracking/stats
TypeScript: tracking.getStats()
Python: tracking.get_stats()
Ruby: tracking.get_stats
PHP: tracking->getStats
Go: Tracking.GetStats
Java: tracking().getStats
CLI: openemail tracking get-stats

`Tracking.GetAsync`

Read one message's engagement report

emails:read

Nënshkrimi

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

Returns the whole report for one tracked message: totals, one entry per tracked copy under recipients, and every rewritten link with its clicks under links. It accepts either identifier a caller may hold. A msg_ id is looked up as the send it went out as, and anything else is treated as a tmsg_ tracking id, which is what Tracking.ListAsync and webhook payloads carry for mail sent outside this API.

openCount and clickCount are counted readings: opens that looked like a person, with repeat fetches within thirty seconds collapsed. openCountRaw and clickCountRaw include every hit, machine fetches such as Apple Mail Privacy Protection and corporate scanners among them. Gmail's image proxy is a real person displaying the message and is counted, but only once, because later views are served from its cache.

recipients is one entry per tracked copy, which is not always one entry per person. When one body went to the whole list, or the bytes could not vary per recipient, the shared copy has email null and attributed false. Branch on attributed and on the message-level attributable before saying that a named person has or has not read anything.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A JsonObject with id, sendId, threadId, subject, from, source, sentAt, opens, clicks, opened, clicked, attributable, counted and raw open and click counts, first and last open and click times, recipients and links.

Shembull

var report = await client.Tracking.GetAsync("tmsg_8b2e4d71c09f3a65e1d7b402"); Console.WriteLine($"{report["openCount"]} counted opens of {report["openCountRaw"]} hits");

Shënime

A 404 means nothing was tracked for that message, which is not the same as nobody having opened it.
opens and clicks record what was applied when the message was sent. Turning tracking on later does not make earlier mail start reporting.
Only links in the new part of a body are rewritten, so quoted history under a reply never appears in links.

E disponueshme edhe në

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

`Tracking.ListOpensAsync`

List the individual opens behind a message's open count

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

Task<Page> ListOpensAsync(    string id,    bool? includeMachine = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one page of the raw open hits for one tracked message, newest first. nextCursor is the opn_ id of the last hit on the page, and passing it back as cursor continues strictly after it, so every stored hit is reachable; ListAllOpensAsync and IterateOpensAsync do that walk for you. Each hit says which copy was fetched, how it was classified, whether it moved the numbers, and what the User-Agent and the edge could tell about the client, device and location.

kind is human for something that looked like a person reading, proxy for an image proxy such as Gmail's, which is a genuine reading by a reader the tracker cannot see, and machine for a scanner or Apple Mail Privacy Protection, which fetches on delivery and only proves the message arrived. By default only counted hits come back. includeMachine: true adds the hits that did not count, which is every machine hit plus repeat fetches within thirty seconds of a counted one on the same copy, so it filters on counted rather than on kind.

A msg_ send id is resolved first, and one that names no tracked message is a 404 rather than an empty list, since an empty list reads as nobody having opened it. A tmsg_ id is taken as given without a lookup, so one that never existed or belongs to another workspace comes back as an empty list. Only read an empty result as an answer about readers when the id came from this API.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
includeMachinebool?: Defaults to false. True also returns hits with counted false, machine fetches and collapsed repeats alike.
limitint?: Hits per page, from 1 to 200, defaulting to 50.
cursorstring?: The nextCursor from the previous page, an opn_ id. Anything else, or one from another message's log, is a 400 invalid_cursor.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A Page with items, hasMore and nextCursor. Each item has object set to open, id, trackedMessageId, recipient, kind, counted, userAgent, client, device, os, country, region, city and createdAt.

Shembull

var page = await client.Tracking.ListOpensAsync("msg_3f9a1c07d2b84e6a9c5b1f20", includeMachine: true, limit: 200); foreach (var open in page){    var counted = (bool?)open["counted"] == true ? "counted" : "not counted";     Console.WriteLine($"{open["createdAt"]} {open["kind"]} {counted} {open["client"]?.ToString() ?? "unknown client"}");}

Shënime

An open row carries no IP address, and country, region and city are what the edge already knew, so on a proxied hit they describe the proxy rather than the reader. The address the request came from is still kept: it goes into the event log for the message, which Emails.ListEventsAsync returns, and into the email.opened webhook payload.
recipient is null on a shared copy, for the same reason the email of an entry in recipients is null on the report.

E disponueshme edhe në

API: GET /tracking/{id}/opens
TypeScript: tracking.listOpens()
Python: tracking.list_opens()
Ruby: tracking.list_opens
PHP: tracking->listOpens
Go: Tracking.ListOpens
Java: tracking().listOpens
CLI: openemail tracking list-opens

`Tracking.ListAllOpensAsync`

Collect every open hit on one message into one object

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

Task<IReadOnlyList<JsonObject>> ListAllOpensAsync(    string id,    bool? includeMachine = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Walks every page of one tracked message's open log and returns all of its hits, newest first. It takes the same named arguments as ListOpensAsync, so by default only counted hits come back and includeMachine: true adds the rest.

A message opened by a mailing list of thousands can hold a great many rows. Prefer IterateOpensAsync when you can stop early. limit sets the page size of each request, not the total.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
includeMachinebool?: Defaults to false. True also returns hits with counted false.
limitint?: Page size per request, from 1 to 200, defaulting to 50 on the server.
cursorstring?: An opn_ id to start after, skipping every newer open.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A list of JsonObject items holding every hit across all pages, newest first.

Shembull

var opens = await client.Tracking.ListAllOpensAsync("msg_3f9a1c07d2b84e6a9c5b1f20", includeMachine: true, limit: 200); Console.WriteLine(opens.Count);

Shënime

A failure on any page throws out of the whole call, and the hits already fetched are discarded.
The same id rules as ListOpensAsync apply: a msg_ id that names no tracked message is a 404, and an unknown tmsg_ id collects an empty object.

E disponueshme edhe në

API: GET /tracking/{id}/opens
TypeScript: tracking.listAllOpens()
Python: tracking.list_all_opens()
Ruby: tracking.list_all_opens
PHP: tracking->listAllOpens
Go: Tracking.ListAllOpens
Java: tracking().listAllOpens

`Tracking.IterateOpensAsync`

Stream the open hits on one message one at a time

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

IAsyncEnumerable<JsonObject> IterateOpensAsync(    string id,    bool? includeMachine = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns an IAsyncEnumerable<JsonObject> over one tracked message's open log that yields hits individually, newest first, and fetches the next page only when the current one is drained. Nothing is requested until you consume it, and breaking out of the loop stops further requests.

The walk ends when hasMore is false. Hits recorded after the walk starts are newer than its cursor and are not yielded.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
includeMachinebool?: Defaults to false. True also returns hits with counted false.
limitint?: Page size per request, from 1 to 200, defaulting to 50 on the server.
cursorstring?: An opn_ id to start after, skipping every newer open.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

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

Shembull

await foreach (var open in client.Tracking.IterateOpensAsync("tmsg_8b2e4d71c09f3a65e1d7b402")){    if ((string?)open["kind"] == "human")    {        Console.WriteLine($"Last read by a person at {open["createdAt"]}");         break;    }}

Shënime

The generator is lazy, so an abandoned loop costs only the pages you consumed.

E disponueshme edhe në

API: GET /tracking/{id}/opens
TypeScript: tracking.iterateOpens()
Python: tracking.iterate_opens()
Ruby: tracking.iterate_opens
PHP: tracking->iterateOpens
Go: Tracking.IterateOpens
Java: tracking().iterateOpens

`Tracking.ListClicksAsync`

List the individual link clicks on a message

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

Task<Page> ListClicksAsync(    string id,    bool? includeMachine = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns one page of the raw click hits for one tracked message, newest first. nextCursor is the clk_ id of the last hit on the page, and passing it back as cursor continues strictly after it, so every stored hit is reachable; ListAllClicksAsync and IterateClicksAsync do that walk for you. Each hit has the same classification and client detail as an open, plus linkId and url naming the link that was followed, where url is the original destination rather than the redirect.

A click is stronger evidence of reading than an open. Mail clients block images far more often than readers leave links unfollowed, so a message with clicks and no opens was certainly read. Link scanners that follow every URL on delivery are classified as machine and excluded from the default result, and includeMachine: true brings them back along with repeat hits collapsed by the thirty second window.

Only links in the new part of the body were rewritten, so nothing here can be a click on quoted history under a reply. The id rules match listOpens: a msg_ id that names no tracked message is a 404, while a tmsg_ id is used without a lookup and an unknown one returns an empty list.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
includeMachinebool?: Defaults to false. True also returns hits with counted false, scanner clicks and collapsed repeats alike.
limitint?: Hits per page, from 1 to 200, defaulting to 50.
cursorstring?: The nextCursor from the previous page, a clk_ id. Anything else, or one from another message's log, is a 400 invalid_cursor.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A Page with items, hasMore and nextCursor. Each item has object set to click, id, trackedMessageId, linkId, url, recipient, kind, counted, userAgent, client, device, os, country, region, city and createdAt.

Shembull

var page = await client.Tracking.ListClicksAsync("tmsg_8b2e4d71c09f3a65e1d7b402", limit: 200); if (page.HasMore){    Console.WriteLine($"More after {page.NextCursor}");}

Shënime

Repeated destinations share one linkId on the report, so a page linked from a header image, a button and a footer is one link. Group by linkId to match links on Tracking.GetAsync.
A key with an address allowlist gets a 404 for a msg_ id sent from an address outside it, and a tmsg_ id is then looked up rather than taken as given.

E disponueshme edhe në

API: GET /tracking/{id}/clicks
TypeScript: tracking.listClicks()
Python: tracking.list_clicks()
Ruby: tracking.list_clicks
PHP: tracking->listClicks
Go: Tracking.ListClicks
Java: tracking().listClicks
CLI: openemail tracking list-clicks

`Tracking.ListAllClicksAsync`

Collect every click hit on one message into one object

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

Task<IReadOnlyList<JsonObject>> ListAllClicksAsync(    string id,    bool? includeMachine = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Walks every page of one tracked message's click log and returns all of its hits, newest first. It takes the same named arguments as ListClicksAsync, so by default only counted hits come back and includeMachine: true adds the rest.

A message opened by a mailing list of thousands can hold a great many rows. Prefer IterateClicksAsync when you can stop early. limit sets the page size of each request, not the total.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
includeMachinebool?: Defaults to false. True also returns hits with counted false.
limitint?: Page size per request, from 1 to 200, defaulting to 50 on the server.
cursorstring?: A clk_ id to start after, skipping every newer click.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

A list of JsonObject items holding every hit across all pages, newest first.

Shembull

var clicks = await client.Tracking.ListAllClicksAsync("tmsg_8b2e4d71c09f3a65e1d7b402"); Console.WriteLine(clicks.Count);

Shënime

A failure on any page throws out of the whole call, and the hits already fetched are discarded.
The same id rules as ListClicksAsync apply: a msg_ id that names no tracked message is a 404, and an unknown tmsg_ id collects an empty object.

E disponueshme edhe në

API: GET /tracking/{id}/clicks
TypeScript: tracking.listAllClicks()
Python: tracking.list_all_clicks()
Ruby: tracking.list_all_clicks
PHP: tracking->listAllClicks
Go: Tracking.ListAllClicks
Java: tracking().listAllClicks

`Tracking.IterateClicksAsync`

Stream the click hits on one message one at a time

emails:readKalon nëpër rezultate faqe pas faqeje

Nënshkrimi

IAsyncEnumerable<JsonObject> IterateClicksAsync(    string id,    bool? includeMachine = null,    int? limit = null,    string? cursor = null,    string? apiKey = null,    CancellationToken cancellationToken = default)

Returns an IAsyncEnumerable<JsonObject> over one tracked message's click log that yields hits individually, newest first, and fetches the next page only when the current one is drained. Nothing is requested until you consume it, and breaking out of the loop stops further requests.

The walk ends when hasMore is false. Hits recorded after the walk starts are newer than its cursor and are not yielded.

Parametrat

idstringE detyrueshme: A tmsg_ tracking id or the msg_ send id the message went out as.
includeMachinebool?: Defaults to false. True also returns hits with counted false.
limitint?: Page size per request, from 1 to 200, defaulting to 50 on the server.
cursorstring?: A clk_ id to start after, skipping every newer click.
apiKeystring?: Reads with this key instead of the client's.
cancellationTokenCancellationToken: Cancels the request.

Kthen

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

Shembull

await foreach (var click in client.Tracking.IterateClicksAsync("tmsg_8b2e4d71c09f3a65e1d7b402")){    Console.WriteLine(click["id"]);}

Shënime

The generator is lazy, so an abandoned loop costs only the pages you consumed.

E disponueshme edhe në

API: GET /tracking/{id}/clicks
TypeScript: tracking.iterateClicks()
Python: tracking.iterate_clicks()
Ruby: tracking.iterate_clicks
PHP: tracking->iterateClicks
Go: Tracking.IterateClicks
Java: tracking().iterateClicks

client.Tracking

Metodat

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Parametrat

Kthen

Shembull

Shënime

E disponueshme edhe në

Kutia juaj hyrëse,sipas kushteve tuaja.

Kutia juaj hyrëse,
sipas kushteve tuaja.