? | See [Attachments](#attachments). |
`SendResult` has `Id`, `Status`, and `To`.
## Attachments
Use `Attach`. For text, pass a string. For binary data, pass a byte array and a content type. The SDK base64-encodes the content for you.
```csharp theme={null}
var email = new Email
{
From = "billing@yourdomain.com",
To = "user@example.com",
Subject = "Your receipt",
Html = "Your receipt is attached.
",
};
email.Attach("receipt.pdf", await File.ReadAllBytesAsync("receipt.pdf"), "application/pdf");
email.Attach("notes.txt", "Thanks for your order.", "text/plain");
await sf.SendAsync(email);
```
Limits:
* Up to 10 attachments per message.
* Up to 10 MB per attachment. Larger files are rejected with `422`.
## Send a batch
`BatchAsync` sends up to 100 emails in one request and returns a `List` in the same order as your input.
```csharp theme={null}
var results = await sf.BatchAsync(new List
{
new() { From = "news@yourdomain.com", To = "a@example.com", Subject = "Digest", Html = "Hi A
" },
new() { From = "news@yourdomain.com", To = "b@example.com", Subject = "Digest", Html = "Hi B
" },
});
```
An empty list, or more than 100 emails, throws `ArgumentException` or `ArgumentOutOfRangeException` before any request is made. See [Batch sending](/guides/batch-sending).
The .NET SDK doesn't send an `Idempotency-Key` header yet, so a retried send can deliver twice. Check the earlier result before you retry. See [Idempotency](/guides/idempotency).
## Manage emails
The .NET SDK can list emails. It doesn't have methods to get or cancel a single email yet. Use `GET /v1/emails/{id}` or `DELETE /v1/emails/{id}` directly if you need them.
```csharp theme={null}
var page = await sf.ListEmailsAsync(limit: 20, offset: 0); // returns a JsonElement
```
## Domains
```csharp theme={null}
var domain = await sf.AddDomainAsync("yourdomain.com"); // returns a JsonElement
Console.WriteLine(domain.GetProperty("id").GetString());
var all = await sf.ListDomainsAsync();
// Run after the DNS records are live. Changes can take time to propagate.
var state = await sf.VerifyDomainAsync(domain.GetProperty("id").GetString()!);
```
You can send only from a verified domain. For DNS setup, see [Domains](/concepts/domains).
## Suppressions
```csharp theme={null}
await sf.SuppressAsync("user@example.com", "unsubscribe");
```
The second argument is optional and defaults to `"unsubscribe"`. See [Emails](/concepts/emails).
## Usage
```csharp theme={null}
var usage = await sf.UsageAsync(); // usage counts for your account, as a JsonElement
```
The .NET SDK doesn't have a health method yet. Call `GET /health` directly if you need one.
## Verify webhooks
SendFlit signs each webhook. The `X-Sendflit-Signature` header carries `sha256=`, an HMAC-SHA256 of the raw request body. Pass the raw bytes to the static method.
```csharp theme={null}
using SendFlit;
// Read the raw body before anything parses it.
using var buffer = new MemoryStream();
await Request.Body.CopyToAsync(buffer);
var raw = buffer.ToArray();
var ok = Client.VerifyWebhookSignature(
Environment.GetEnvironmentVariable("SENDFLIT_WEBHOOK_SECRET")!,
raw,
Request.Headers["X-Sendflit-Signature"].ToString());
if (!ok)
{
return Results.StatusCode(401);
}
// parse raw and handle the event here
```
The comparison runs in constant time. See [Webhooks](/reference/webhooks) for the event list.
## Errors and retries
Failed calls throw `SendFlitException`, which has two properties:
| Property | Meaning |
| - | - |
| `Status` | The HTTP status code. `0` for a network failure. |
| `Body` | The raw response body, when the API returned one. |
```csharp theme={null}
try
{
await sf.SendAsync(email);
}
catch (SendFlitException e) when (e.Status == 422)
{
Console.Error.WriteLine($"Invalid email: {e.Body}");
}
```
Requests that fail with `429` or `5xx` are retried up to `maxRetries` times. The SDK honors the `Retry-After` header when it's present. Other `4xx` responses are not retried. See [Errors, retries and limits](/reference/errors).
## Method reference
| Method | Endpoint | Returns |
| - | - | - |
| `SendAsync(Email)` | `POST /v1/email` | `SendResult` |
| `BatchAsync(List)` | `POST /v1/emails/batch` | `List` |
| `ListEmailsAsync(limit, offset, status)` | `GET /v1/emails` | `JsonElement` |
| `AddDomainAsync(name)` | `POST /v1/domains` | `JsonElement` |
| `ListDomainsAsync()` | `GET /v1/domains` | `JsonElement` |
| `VerifyDomainAsync(id)` | `POST /v1/domains/{id}/verify` | `JsonElement` |
| `SuppressAsync(email, reason)` | `POST /v1/suppressions` | `JsonElement` |
| `UsageAsync()` | `GET /v1/usage` | `JsonElement` |
| `Client.VerifyWebhookSignature(secret, rawBody, signature)` | none, local check | `bool` |
## Next steps
* [Quickstart](/quickstart): send your first email from the command line.
* [Batch sending](/guides/batch-sending): limits and per-item results.
* [Webhooks](/reference/webhooks): events and payloads.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.