# Use the TypeScript, Python and Go SDKs

> The TypeScript SDK with resource methods, automatic idempotency keys and typed errors, and the generated Python and Go clients.

Source: https://docs.minket.com/sdks/
Updated: 2026-10-30

## One document, three SDKs

Every SDK is generated from the API's OpenAPI document ([openapi.json](https://docs.minket.com/openapi.json)), so it never lags the API, and every one is tested against the API on each change. Operation ids in the [API reference](https://docs.minket.com/api/) name the same operation in every SDK:

| | TypeScript | Python | Go |
|---|---|---|---|
| Package | `@minket/sdk` (`packages/sdk`) | `minket` (`sdks/python`) | `github.com/blawand/minket/sdks/go/minket` |
| `sendEmail` becomes | `minket.emails.send(body)` | `minket.api.emails.send_email.sync(client=…, body=…)` | `client.SendEmailWithResponse(ctx, body)` |
| Regenerate | `pnpm generate` | `bash sdks/python/generate.sh` | `bash sdks/go/generate.sh` |

## TypeScript

```ts
import { Minket } from "@minket/sdk";

const minket = new Minket({ apiKey: process.env.MINKET_API_KEY ?? "" });

const sent = await minket.emails.send({
  from: "Acme <billing@mail.acme.example>",
  to: "jane@example.com",
  subject: "Your receipt for order 10452",
  text: "Thanks, Jane.",
  tags: [{ name: "type", value: "receipt" }],
});
// sent.id, sent.status ("queued"), sent.idempotent_replay

const email = await minket.emails.get(sent.id);
const bounces = await minket.events.list({ types: "email.bounced", limit: 50 });
```

The guides' TypeScript samples use this `minket`. `baseUrl` points it at another API address. Resource methods follow the API's groups: `emails`, `uploads`, `attachments`, `templates`, `domains`, `webhooks`, `events`, `inbound` (with `inbound.routes`), `mailboxes`, `suppressions`, `contacts` (with `contacts.imports` and `contacts.properties`), `segments` (with `segments.contacts`), `topics`, `broadcasts`, `automations`, `keys`, `logs` and `members`. Path parameters come first, then the body or the query, then options: `minket.webhooks.replay(id, { since })`, `minket.contacts.get("jane@example.com")`. Each returns the typed success body; the [operation table](https://docs.minket.com/sdks/#operations) names the method for every operation.

### Idempotency

Every POST carries an `Idempotency-Key`: a fresh UUIDv7 unless you give one, so a retry by a proxy or a network layer can never send twice. To retry safely yourself, pass the same key again ([Idempotency](https://docs.minket.com/sending/#idempotency)):

```ts
await minket.emails.send(receipt, { idempotencyKey: `receipt-${order.id}` });
```

A key in the body (`idempotency_key`) is sent as the header too, since the API prefers the header.

### Errors

Every failure throws `MinketError`:

```ts
import { isMinketError } from "@minket/sdk";

try {
  await minket.emails.send(receipt, { idempotencyKey });
} catch (error) {
  if (isMinketError(error) && error.retryable) {
    // safe to retry with the same idempotency key, after error.retryAfterSeconds if set
  }
  throw error;
}
```

| Property | |
|---|---|
| `code` | The API's error code (`validation_error`, `not_found`, ...), or `network_error` when no response arrived and `unexpected_response` for a body that is not the API's |
| `status` | HTTP status, 0 without a response |
| `message` | What happened and what to do next |
| `retryable` | True when the same request with the same idempotency key can succeed |
| `requestId` | The request's id, for `minket.logs.list()` and support |
| `issues` | Validation issues: `[{ path: "to.0", message }]` |
| `retryAfterSeconds` | From `retry-after`, on rate limits and in-flight idempotency keys |

`error.toJSON()` gives the snake_case wire shape for logs; it never contains request content.

### Files and lists

`minket.uploads.upload({ purpose, filename, content_type, content })` creates a presigned upload, stores the bytes (without the API key) and returns the completed upload, ready for `minket.attachments.create({ upload_id })` or `minket.contacts.import({ upload_id })`. Use it for attachments and imports above 4 MB.

`paginate` walks a list with its `after` cursor:

```ts
import { paginate } from "@minket/sdk";

for await (const entry of paginate((cursor) => minket.suppressions.list({ ...cursor, reason: "hard_bounce" }))) {
  console.log(entry.email);
}
```

### Any operation, and the raw client

`minket.request(operationId, { path, query, body })` calls any operation by its id, typed from the document, with the same auth, idempotency and errors. The generated functions are exported too, for code that prefers `{ data, error }` results to exceptions:

```ts
import { createMinketClient, getEmail } from "@minket/sdk";

const client = createMinketClient({ apiKey: process.env.MINKET_API_KEY ?? "" });
const { data, error, response } = await getEmail({ client, path: { id } });
```

`verifyWebhook` is exported for receivers ([Verify signatures](https://docs.minket.com/webhooks/#verify-signatures)). Pass your own `fetch` to `new Minket({ fetch })` in tests.

## Python

`bash sdks/python/generate.sh` writes the project to `sdks/python/minket`; install it with `pip install ./sdks/python/minket`. Every operation is a module under `minket.api.<group>` with `sync`, `sync_detailed`, `asyncio` and `asyncio_detailed`; the detailed variants return the status code, headers and parsed body, and error statuses parse into `ApiError`.

```python
import os

from minket import AuthenticatedClient
from minket.api.emails import get_email, send_email
from minket.models import ApiError, SendEmailRequest

base_url = "https://api.minket.com"
token = os.environ["MINKET_API_KEY"]
client = AuthenticatedClient(base_url=base_url, token=token)

# A client per idempotency key: with_headers() also changes a client that has made a request.
keyed = AuthenticatedClient(base_url=base_url, token=token, headers={"Idempotency-Key": "receipt-10452"})
sent = send_email.sync_detailed(
    client=keyed,
    body=SendEmailRequest(
        from_="Acme <billing@mail.acme.example>",
        to=["jane@example.com"],
        subject="Your receipt for order 10452",
        text="Thanks, Jane.",
    ),
)
if isinstance(sent.parsed, ApiError):
    print(sent.parsed.error.code, sent.parsed.error.retryable)
else:
    email = get_email.sync(sent.parsed.id, client=client)
```

`from` is `from_` because it is a keyword. Path parameters are positional, query parameters keyword arguments, and bodies model instances (or `Model.from_dict({...})`).

## Go

`bash sdks/go/generate.sh` writes package `minket` (`client.gen.go`): a typed client with request and response types for every operation. Add the bearer token and an idempotency key with a request editor:

```go
client, err := minket.NewClientWithResponses(
	"https://api.minket.com",
	minket.WithRequestEditorFn(func(ctx context.Context, req *http.Request) error {
		req.Header.Set("Authorization", "Bearer "+os.Getenv("MINKET_API_KEY"))
		if req.Method == http.MethodPost && req.Header.Get("Idempotency-Key") == "" {
			req.Header.Set("Idempotency-Key", newKey())
		}
		return nil
	}),
)
if err != nil {
	return err
}

var to minket.SendEmailRequest_To
_ = to.FromSendEmailRequestTo1([]string{"jane@example.com"})
from, subject, text := "Acme <billing@mail.acme.example>", "Your receipt", "Thanks, Jane."
res, err := client.SendEmailWithResponse(ctx, minket.SendEmailRequest{From: &from, To: to, Subject: &subject, Text: &text})
if err != nil {
	return err
}
if res.JSON200 != nil {
	fmt.Println(res.JSON200.Id, res.JSON200.Status)
} else if res.JSON422 != nil {
	fmt.Println(res.JSON422.Error.Code, res.JSON422.Error.Message)
}
```

Response structs carry one field per documented status (`JSON200`, `JSON404`, ...), so error bodies are typed. Fields that take one address or a list are unions set with `From...To0` (a string) or `From...To1` (a slice).

## Operations

Every operation in the current document, by group, with its name in each SDK. The operation links to its reference entry.

### Emails

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`getEmailMetrics`](https://docs.minket.com/api/emails/#getEmailMetrics) | `minket.emails.metrics` | `minket.api.emails.get_email_metrics` | `GetEmailMetricsWithResponse` |
| [`sendEmail`](https://docs.minket.com/api/emails/#sendEmail) | `minket.emails.send` | `minket.api.emails.send_email` | `SendEmailWithResponse` |
| [`listEmails`](https://docs.minket.com/api/emails/#listEmails) | `minket.emails.list` | `minket.api.emails.list_emails` | `ListEmailsWithResponse` |
| [`sendBatch`](https://docs.minket.com/api/emails/#sendBatch) | `minket.emails.sendBatch` | `minket.api.emails.send_batch` | `SendBatchWithResponse` |
| [`getEmail`](https://docs.minket.com/api/emails/#getEmail) | `minket.emails.get` | `minket.api.emails.get_email` | `GetEmailWithResponse` |
| [`rescheduleEmail`](https://docs.minket.com/api/emails/#rescheduleEmail) | `minket.emails.reschedule` | `minket.api.emails.reschedule_email` | `RescheduleEmailWithResponse` |
| [`cancelEmail`](https://docs.minket.com/api/emails/#cancelEmail) | `minket.emails.cancel` | `minket.api.emails.cancel_email` | `CancelEmailWithResponse` |
| [`listEmailEvents`](https://docs.minket.com/api/emails/#listEmailEvents) | `minket.emails.events` | `minket.api.emails.list_email_events` | `ListEmailEventsWithResponse` |
| [`listEmailAttachments`](https://docs.minket.com/api/emails/#listEmailAttachments) | `minket.emails.attachments` | `minket.api.emails.list_email_attachments` | `ListEmailAttachmentsWithResponse` |
| [`shareEmail`](https://docs.minket.com/api/emails/#shareEmail) | `minket.emails.share` | `minket.api.emails.share_email` | `ShareEmailWithResponse` |

### Attachments

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createAttachment`](https://docs.minket.com/api/attachments/#createAttachment) | `minket.attachments.create` | `minket.api.attachments.create_attachment` | `CreateAttachmentWithResponse` |
| [`listAttachments`](https://docs.minket.com/api/attachments/#listAttachments) | `minket.attachments.list` | `minket.api.attachments.list_attachments` | `ListAttachmentsWithResponse` |
| [`getAttachment`](https://docs.minket.com/api/attachments/#getAttachment) | `minket.attachments.get` | `minket.api.attachments.get_attachment` | `GetAttachmentWithResponse` |
| [`deleteAttachment`](https://docs.minket.com/api/attachments/#deleteAttachment) | `minket.attachments.delete` | `minket.api.attachments.delete_attachment` | `DeleteAttachmentWithResponse` |

### Uploads

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createUpload`](https://docs.minket.com/api/uploads/#createUpload) | `minket.uploads.create` | `minket.api.uploads.create_upload` | `CreateUploadWithResponse` |
| [`getUpload`](https://docs.minket.com/api/uploads/#getUpload) | `minket.uploads.get` | `minket.api.uploads.get_upload` | `GetUploadWithResponse` |

### Templates

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createTemplate`](https://docs.minket.com/api/templates/#createTemplate) | `minket.templates.create` | `minket.api.templates.create_template` | `CreateTemplateWithResponse` |
| [`listTemplates`](https://docs.minket.com/api/templates/#listTemplates) | `minket.templates.list` | `minket.api.templates.list_templates` | `ListTemplatesWithResponse` |
| [`getTemplate`](https://docs.minket.com/api/templates/#getTemplate) | `minket.templates.get` | `minket.api.templates.get_template` | `GetTemplateWithResponse` |
| [`updateTemplate`](https://docs.minket.com/api/templates/#updateTemplate) | `minket.templates.update` | `minket.api.templates.update_template` | `UpdateTemplateWithResponse` |
| [`deleteTemplate`](https://docs.minket.com/api/templates/#deleteTemplate) | `minket.templates.delete` | `minket.api.templates.delete_template` | `DeleteTemplateWithResponse` |
| [`publishTemplate`](https://docs.minket.com/api/templates/#publishTemplate) | `minket.templates.publish` | `minket.api.templates.publish_template` | `PublishTemplateWithResponse` |
| [`duplicateTemplate`](https://docs.minket.com/api/templates/#duplicateTemplate) | `minket.templates.duplicate` | `minket.api.templates.duplicate_template` | `DuplicateTemplateWithResponse` |
| [`listTemplateVersions`](https://docs.minket.com/api/templates/#listTemplateVersions) | `minket.templates.versions` | `minket.api.templates.list_template_versions` | `ListTemplateVersionsWithResponse` |
| [`getTemplateVersion`](https://docs.minket.com/api/templates/#getTemplateVersion) | `minket.templates.version` | `minket.api.templates.get_template_version` | `GetTemplateVersionWithResponse` |
| [`previewTemplate`](https://docs.minket.com/api/templates/#previewTemplate) | `minket.templates.preview` | `minket.api.templates.preview_template` | `PreviewTemplateWithResponse` |

### Domains

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createDomain`](https://docs.minket.com/api/domains/#createDomain) | `minket.domains.create` | `minket.api.domains.create_domain` | `CreateDomainWithResponse` |
| [`listDomains`](https://docs.minket.com/api/domains/#listDomains) | `minket.domains.list` | `minket.api.domains.list_domains` | `ListDomainsWithResponse` |
| [`getDomain`](https://docs.minket.com/api/domains/#getDomain) | `minket.domains.get` | `minket.api.domains.get_domain` | `GetDomainWithResponse` |
| [`updateDomain`](https://docs.minket.com/api/domains/#updateDomain) | `minket.domains.update` | `minket.api.domains.update_domain` | `UpdateDomainWithResponse` |
| [`deleteDomain`](https://docs.minket.com/api/domains/#deleteDomain) | `minket.domains.delete` | `minket.api.domains.delete_domain` | `DeleteDomainWithResponse` |
| [`verifyDomain`](https://docs.minket.com/api/domains/#verifyDomain) | `minket.domains.verify` | `minket.api.domains.verify_domain` | `VerifyDomainWithResponse` |
| [`listDomainDmarcReports`](https://docs.minket.com/api/domains/#listDomainDmarcReports) | `minket.domains.dmarcReports` | `minket.api.domains.list_domain_dmarc_reports` | `ListDomainDmarcReportsWithResponse` |
| [`getDomainReputation`](https://docs.minket.com/api/domains/#getDomainReputation) | `minket.domains.reputation` | `minket.api.domains.get_domain_reputation` | `GetDomainReputationWithResponse` |
| [`runSeedTest`](https://docs.minket.com/api/domains/#runSeedTest) | `minket.domains.seedTest` | `minket.api.domains.run_seed_test` | `RunSeedTestWithResponse` |

### Webhooks

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createWebhook`](https://docs.minket.com/api/webhooks/#createWebhook) | `minket.webhooks.create` | `minket.api.webhooks.create_webhook` | `CreateWebhookWithResponse` |
| [`listWebhooks`](https://docs.minket.com/api/webhooks/#listWebhooks) | `minket.webhooks.list` | `minket.api.webhooks.list_webhooks` | `ListWebhooksWithResponse` |
| [`getWebhook`](https://docs.minket.com/api/webhooks/#getWebhook) | `minket.webhooks.get` | `minket.api.webhooks.get_webhook` | `GetWebhookWithResponse` |
| [`updateWebhook`](https://docs.minket.com/api/webhooks/#updateWebhook) | `minket.webhooks.update` | `minket.api.webhooks.update_webhook` | `UpdateWebhookWithResponse` |
| [`deleteWebhook`](https://docs.minket.com/api/webhooks/#deleteWebhook) | `minket.webhooks.delete` | `minket.api.webhooks.delete_webhook` | `DeleteWebhookWithResponse` |
| [`rotateWebhookSecret`](https://docs.minket.com/api/webhooks/#rotateWebhookSecret) | `minket.webhooks.rotateSecret` | `minket.api.webhooks.rotate_webhook_secret` | `RotateWebhookSecretWithResponse` |
| [`listWebhookDeliveries`](https://docs.minket.com/api/webhooks/#listWebhookDeliveries) | `minket.webhooks.deliveries` | `minket.api.webhooks.list_webhook_deliveries` | `ListWebhookDeliveriesWithResponse` |
| [`getWebhookDelivery`](https://docs.minket.com/api/webhooks/#getWebhookDelivery) | `minket.webhooks.delivery` | `minket.api.webhooks.get_webhook_delivery` | `GetWebhookDeliveryWithResponse` |
| [`replayWebhookDeliveries`](https://docs.minket.com/api/webhooks/#replayWebhookDeliveries) | `minket.webhooks.replay` | `minket.api.webhooks.replay_webhook_deliveries` | `ReplayWebhookDeliveriesWithResponse` |
| [`testWebhook`](https://docs.minket.com/api/webhooks/#testWebhook) | `minket.webhooks.test` | `minket.api.webhooks.test_webhook` | `TestWebhookWithResponse` |

### Events

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listEvents`](https://docs.minket.com/api/events/#listEvents) | `minket.events.list` | `minket.api.events.list_events` | `ListEventsWithResponse` |
| [`getEvent`](https://docs.minket.com/api/events/#getEvent) | `minket.events.get` | `minket.api.events.get_event` | `GetEventWithResponse` |

### Inbound

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listInboundRoutes`](https://docs.minket.com/api/inbound/#listInboundRoutes) | `minket.inbound.routes.list` | `minket.api.inbound.list_inbound_routes` | `ListInboundRoutesWithResponse` |
| [`createInboundRoute`](https://docs.minket.com/api/inbound/#createInboundRoute) | `minket.inbound.routes.create` | `minket.api.inbound.create_inbound_route` | `CreateInboundRouteWithResponse` |
| [`updateInboundRoute`](https://docs.minket.com/api/inbound/#updateInboundRoute) | `minket.inbound.routes.update` | `minket.api.inbound.update_inbound_route` | `UpdateInboundRouteWithResponse` |
| [`deleteInboundRoute`](https://docs.minket.com/api/inbound/#deleteInboundRoute) | `minket.inbound.routes.delete` | `minket.api.inbound.delete_inbound_route` | `DeleteInboundRouteWithResponse` |
| [`listInbound`](https://docs.minket.com/api/inbound/#listInbound) | `minket.inbound.list` | `minket.api.inbound.list_inbound` | `ListInboundWithResponse` |
| [`getInbound`](https://docs.minket.com/api/inbound/#getInbound) | `minket.inbound.get` | `minket.api.inbound.get_inbound` | `GetInboundWithResponse` |
| [`listInboundAttachments`](https://docs.minket.com/api/inbound/#listInboundAttachments) | `minket.inbound.attachments` | `minket.api.inbound.list_inbound_attachments` | `ListInboundAttachmentsWithResponse` |
| [`getInboundAttachment`](https://docs.minket.com/api/inbound/#getInboundAttachment) | `minket.inbound.attachment` | `minket.api.inbound.get_inbound_attachment` | `GetInboundAttachmentWithResponse` |
| [`forwardInbound`](https://docs.minket.com/api/inbound/#forwardInbound) | `minket.inbound.forward` | `minket.api.inbound.forward_inbound` | `ForwardInboundWithResponse` |
| [`shareInbound`](https://docs.minket.com/api/inbound/#shareInbound) | `minket.inbound.share` | `minket.api.inbound.share_inbound` | `ShareInboundWithResponse` |

### Mailboxes

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listMailboxes`](https://docs.minket.com/api/mailboxes/#listMailboxes) | `minket.mailboxes.list` | `minket.api.mailboxes.list_mailboxes` | `ListMailboxesWithResponse` |
| [`createMailbox`](https://docs.minket.com/api/mailboxes/#createMailbox) | `minket.mailboxes.create` | `minket.api.mailboxes.create_mailbox` | `CreateMailboxWithResponse` |
| [`getMailbox`](https://docs.minket.com/api/mailboxes/#getMailbox) | `minket.mailboxes.get` | `minket.api.mailboxes.get_mailbox` | `GetMailboxWithResponse` |
| [`deleteMailbox`](https://docs.minket.com/api/mailboxes/#deleteMailbox) | `minket.mailboxes.delete` | `minket.api.mailboxes.delete_mailbox` | `DeleteMailboxWithResponse` |

### Suppressions

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listSuppressions`](https://docs.minket.com/api/suppressions/#listSuppressions) | `minket.suppressions.list` | `minket.api.suppressions.list_suppressions` | `ListSuppressionsWithResponse` |
| [`createSuppression`](https://docs.minket.com/api/suppressions/#createSuppression) | `minket.suppressions.create` | `minket.api.suppressions.create_suppression` | `CreateSuppressionWithResponse` |
| [`deleteSuppression`](https://docs.minket.com/api/suppressions/#deleteSuppression) | `minket.suppressions.delete` | `minket.api.suppressions.delete_suppression` | `DeleteSuppressionWithResponse` |

### Contacts

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createContact`](https://docs.minket.com/api/contacts/#createContact) | `minket.contacts.create` | `minket.api.contacts.create_contact` | `CreateContactWithResponse` |
| [`listContacts`](https://docs.minket.com/api/contacts/#listContacts) | `minket.contacts.list` | `minket.api.contacts.list_contacts` | `ListContactsWithResponse` |
| [`importContacts`](https://docs.minket.com/api/contacts/#importContacts) | `minket.contacts.import` | `minket.api.contacts.import_contacts` | `ImportContactsWithResponse` |
| [`listImports`](https://docs.minket.com/api/contacts/#listImports) | `minket.contacts.imports.list` | `minket.api.contacts.list_imports` | `ListImportsWithResponse` |
| [`getImport`](https://docs.minket.com/api/contacts/#getImport) | `minket.contacts.imports.get` | `minket.api.contacts.get_import` | `GetImportWithResponse` |
| [`exportContacts`](https://docs.minket.com/api/contacts/#exportContacts) | `minket.contacts.export` | `minket.api.contacts.export_contacts` | `ExportContactsWithResponse` |
| [`sendContactEvent`](https://docs.minket.com/api/contacts/#sendContactEvent) | `minket.contacts.sendEvent` | `minket.api.contacts.send_contact_event` | `SendContactEventWithResponse` |
| [`listContactProperties`](https://docs.minket.com/api/contacts/#listContactProperties) | `minket.contacts.properties.list` | `minket.api.contacts.list_contact_properties` | `ListContactPropertiesWithResponse` |
| [`createContactProperty`](https://docs.minket.com/api/contacts/#createContactProperty) | `minket.contacts.properties.create` | `minket.api.contacts.create_contact_property` | `CreateContactPropertyWithResponse` |
| [`deleteContactProperty`](https://docs.minket.com/api/contacts/#deleteContactProperty) | `minket.contacts.properties.delete` | `minket.api.contacts.delete_contact_property` | `DeleteContactPropertyWithResponse` |
| [`getContact`](https://docs.minket.com/api/contacts/#getContact) | `minket.contacts.get` | `minket.api.contacts.get_contact` | `GetContactWithResponse` |
| [`updateContact`](https://docs.minket.com/api/contacts/#updateContact) | `minket.contacts.update` | `minket.api.contacts.update_contact` | `UpdateContactWithResponse` |
| [`deleteContact`](https://docs.minket.com/api/contacts/#deleteContact) | `minket.contacts.delete` | `minket.api.contacts.delete_contact` | `DeleteContactWithResponse` |
| [`listContactConsent`](https://docs.minket.com/api/contacts/#listContactConsent) | `minket.contacts.consent` | `minket.api.contacts.list_contact_consent` | `ListContactConsentWithResponse` |
| [`sendContactOptin`](https://docs.minket.com/api/contacts/#sendContactOptin) | `minket.contacts.optin` | `minket.api.contacts.send_contact_optin` | `SendContactOptinWithResponse` |

### Segments

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createSegment`](https://docs.minket.com/api/segments/#createSegment) | `minket.segments.create` | `minket.api.segments.create_segment` | `CreateSegmentWithResponse` |
| [`listSegments`](https://docs.minket.com/api/segments/#listSegments) | `minket.segments.list` | `minket.api.segments.list_segments` | `ListSegmentsWithResponse` |
| [`getSegment`](https://docs.minket.com/api/segments/#getSegment) | `minket.segments.get` | `minket.api.segments.get_segment` | `GetSegmentWithResponse` |
| [`updateSegment`](https://docs.minket.com/api/segments/#updateSegment) | `minket.segments.update` | `minket.api.segments.update_segment` | `UpdateSegmentWithResponse` |
| [`deleteSegment`](https://docs.minket.com/api/segments/#deleteSegment) | `minket.segments.delete` | `minket.api.segments.delete_segment` | `DeleteSegmentWithResponse` |
| [`listSegmentContacts`](https://docs.minket.com/api/segments/#listSegmentContacts) | `minket.segments.contacts.list` | `minket.api.segments.list_segment_contacts` | `ListSegmentContactsWithResponse` |
| [`addSegmentContacts`](https://docs.minket.com/api/segments/#addSegmentContacts) | `minket.segments.contacts.add` | `minket.api.segments.add_segment_contacts` | `AddSegmentContactsWithResponse` |
| [`removeSegmentContacts`](https://docs.minket.com/api/segments/#removeSegmentContacts) | `minket.segments.contacts.remove` | `minket.api.segments.remove_segment_contacts` | `RemoveSegmentContactsWithResponse` |

### Topics

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createTopic`](https://docs.minket.com/api/topics/#createTopic) | `minket.topics.create` | `minket.api.topics.create_topic` | `CreateTopicWithResponse` |
| [`listTopics`](https://docs.minket.com/api/topics/#listTopics) | `minket.topics.list` | `minket.api.topics.list_topics` | `ListTopicsWithResponse` |
| [`getTopic`](https://docs.minket.com/api/topics/#getTopic) | `minket.topics.get` | `minket.api.topics.get_topic` | `GetTopicWithResponse` |
| [`updateTopic`](https://docs.minket.com/api/topics/#updateTopic) | `minket.topics.update` | `minket.api.topics.update_topic` | `UpdateTopicWithResponse` |
| [`deleteTopic`](https://docs.minket.com/api/topics/#deleteTopic) | `minket.topics.delete` | `minket.api.topics.delete_topic` | `DeleteTopicWithResponse` |

### Broadcasts

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createBroadcast`](https://docs.minket.com/api/broadcasts/#createBroadcast) | `minket.broadcasts.create` | `minket.api.broadcasts.create_broadcast` | `CreateBroadcastWithResponse` |
| [`listBroadcasts`](https://docs.minket.com/api/broadcasts/#listBroadcasts) | `minket.broadcasts.list` | `minket.api.broadcasts.list_broadcasts` | `ListBroadcastsWithResponse` |
| [`getBroadcast`](https://docs.minket.com/api/broadcasts/#getBroadcast) | `minket.broadcasts.get` | `minket.api.broadcasts.get_broadcast` | `GetBroadcastWithResponse` |
| [`updateBroadcast`](https://docs.minket.com/api/broadcasts/#updateBroadcast) | `minket.broadcasts.update` | `minket.api.broadcasts.update_broadcast` | `UpdateBroadcastWithResponse` |
| [`deleteBroadcast`](https://docs.minket.com/api/broadcasts/#deleteBroadcast) | `minket.broadcasts.delete` | `minket.api.broadcasts.delete_broadcast` | `DeleteBroadcastWithResponse` |
| [`sendBroadcast`](https://docs.minket.com/api/broadcasts/#sendBroadcast) | `minket.broadcasts.send` | `minket.api.broadcasts.send_broadcast` | `SendBroadcastWithResponse` |
| [`cancelBroadcast`](https://docs.minket.com/api/broadcasts/#cancelBroadcast) | `minket.broadcasts.cancel` | `minket.api.broadcasts.cancel_broadcast` | `CancelBroadcastWithResponse` |
| [`duplicateBroadcast`](https://docs.minket.com/api/broadcasts/#duplicateBroadcast) | `minket.broadcasts.duplicate` | `minket.api.broadcasts.duplicate_broadcast` | `DuplicateBroadcastWithResponse` |
| [`testBroadcast`](https://docs.minket.com/api/broadcasts/#testBroadcast) | `minket.broadcasts.test` | `minket.api.broadcasts.test_broadcast` | `TestBroadcastWithResponse` |
| [`listBroadcastRecipients`](https://docs.minket.com/api/broadcasts/#listBroadcastRecipients) | `minket.broadcasts.recipients` | `minket.api.broadcasts.list_broadcast_recipients` | `ListBroadcastRecipientsWithResponse` |
| [`listBroadcastLinks`](https://docs.minket.com/api/broadcasts/#listBroadcastLinks) | `minket.broadcasts.links` | `minket.api.broadcasts.list_broadcast_links` | `ListBroadcastLinksWithResponse` |

### Automations

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`createAutomation`](https://docs.minket.com/api/automations/#createAutomation) | `minket.automations.create` | `minket.api.automations.create_automation` | `CreateAutomationWithResponse` |
| [`listAutomations`](https://docs.minket.com/api/automations/#listAutomations) | `minket.automations.list` | `minket.api.automations.list_automations` | `ListAutomationsWithResponse` |
| [`getAutomation`](https://docs.minket.com/api/automations/#getAutomation) | `minket.automations.get` | `minket.api.automations.get_automation` | `GetAutomationWithResponse` |
| [`updateAutomation`](https://docs.minket.com/api/automations/#updateAutomation) | `minket.automations.update` | `minket.api.automations.update_automation` | `UpdateAutomationWithResponse` |
| [`deleteAutomation`](https://docs.minket.com/api/automations/#deleteAutomation) | `minket.automations.delete` | `minket.api.automations.delete_automation` | `DeleteAutomationWithResponse` |
| [`publishAutomation`](https://docs.minket.com/api/automations/#publishAutomation) | `minket.automations.publish` | `minket.api.automations.publish_automation` | `PublishAutomationWithResponse` |
| [`stopAutomation`](https://docs.minket.com/api/automations/#stopAutomation) | `minket.automations.stop` | `minket.api.automations.stop_automation` | `StopAutomationWithResponse` |
| [`duplicateAutomation`](https://docs.minket.com/api/automations/#duplicateAutomation) | `minket.automations.duplicate` | `minket.api.automations.duplicate_automation` | `DuplicateAutomationWithResponse` |
| [`listAutomationVersions`](https://docs.minket.com/api/automations/#listAutomationVersions) | `minket.automations.versions` | `minket.api.automations.list_automation_versions` | `ListAutomationVersionsWithResponse` |
| [`listAutomationRuns`](https://docs.minket.com/api/automations/#listAutomationRuns) | `minket.automations.runs` | `minket.api.automations.list_automation_runs` | `ListAutomationRunsWithResponse` |
| [`getAutomationRun`](https://docs.minket.com/api/automations/#getAutomationRun) | `minket.automations.run` | `minket.api.automations.get_automation_run` | `GetAutomationRunWithResponse` |

### Keys

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listKeys`](https://docs.minket.com/api/keys/#listKeys) | `minket.keys.list` | `minket.api.keys.list_keys` | `ListKeysWithResponse` |
| [`createKey`](https://docs.minket.com/api/keys/#createKey) | `minket.keys.create` | `minket.api.keys.create_key` | `CreateKeyWithResponse` |
| [`getCurrentKey`](https://docs.minket.com/api/keys/#getCurrentKey) | `minket.keys.current` | `minket.api.keys.get_current_key` | `GetCurrentKeyWithResponse` |
| [`revokeKey`](https://docs.minket.com/api/keys/#revokeKey) | `minket.keys.revoke` | `minket.api.keys.revoke_key` | `RevokeKeyWithResponse` |

### Logs

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listLogs`](https://docs.minket.com/api/logs/#listLogs) | `minket.logs.list` | `minket.api.logs.list_logs` | `ListLogsWithResponse` |
| [`getLog`](https://docs.minket.com/api/logs/#getLog) | `minket.logs.get` | `minket.api.logs.get_log` | `GetLogWithResponse` |

### Members

| Operation | TypeScript | Python | Go |
| --- | --- | --- | --- |
| [`listMembers`](https://docs.minket.com/api/members/#listMembers) | `minket.members.list` | `minket.api.members.list_members` | `ListMembersWithResponse` |