# Addons

Managed databases, a key-value store, object storage, outgoing email, and connections to your own mail, SMS, voice and WhatsApp provider accounts you attach with one nesly command. Connection details arrive as environment variables.

An addon is a backing service the platform runs for one of your projects. You attach it once; nesly injects the connection details as environment variables, and the next deploy picks them up. You never get a public address — your application reaches the service on the private network.

Attach with `nesly addon add <type>`, list with `nesly addon ls`, remove with `nesly addon rm <type> --yes`.

## A warning before the build

When your code reads a variable only an addon provides (`DATABASE_URL`,`REDIS_URL`,`MONGODB_URI`, `SMTP_URL`, a `PG*` or`MYSQL_*` name) and the project has neither the addon nor a variable of that name,`nesly deploy` says so before it uploads anything, with the command that attaches it. The deploy goes on; with `--json` the same advice is in `warnings[]`. Only direct reads are looked at (`os.Getenv("DATABASE_URL")`,`process.env.DATABASE_URL`,`os.environ["DATABASE_URL"]`, ...), and a read that carries its own default is not warned about.

## An app that asks for SMTP\_URL

Self-hosted products (a mail tool, a CMS, a forum) often say on their setup screen "set `SMTP_URL`". That is the mail addon: run`nesly addon add mail`, redeploy, and the app finds`SMTP_URL`(`smtp://user:password@host:port`, credentials already encoded),`SMTP_HOST`, `SMTP_PORT`,`SMTP_USER`, `SMTP_PASSWORD` and`SMTP_FROM` in its environment. The connection upgrades to TLS on its own (`smtp://`, not `smtps://`). You can send only as the address in `SMTP_FROM`; if the app wants to send from your own domain, use a mail provider's SMTP address and set `SMTP_URL` yourself with `nesly env set` (a variable you set always wins over the addon's). A project that attached the addon earlier gets the `SMTP_*` names on its next deploy.

## A connection string written for another database

Code written for a database on your own machine (`postgres://localhost/app`,`Server=localhost;…`, a compose service name) cannot reach the addon.`nesly fix dsn` changes exactly that one thing and nothing else: if the code already reads a variable the addon sets, it does nothing; if it reads a variable of its own that is plainly a connection, the addon sets that one too and no file changes; otherwise the connection string becomes a read of the addon's variable, in the language's own spelling. No address and no secret is written into your code. It prints the diff; `--yes` changes the files in place.`nesly deploy` says before the upload when it will make the change itself, and does so on its own copy of the code, so a deploy works either way; `nesly fix show` prints what it changed. A host with a dot in it (`db.example.com`) may be your own database elsewhere and is never touched.

## What you can attach

-   ### PostgreSQL (postgres)
    
    Your own database and login on the shared cluster. Injects DATABASE\_URL. Framework names (Laravel DB\_\*, .NET ConnectionStrings\_\_Default) are derived from it.
    
-   ### MySQL (mysql)
    
    Your own database and login on the shared Percona cluster. Injects DATABASE\_URL. InnoDB only — a MyISAM dump from shared hosting needs converting first.
    
-   ### SQL Server (mssql)
    
    Your own database and login (Express edition, 10 GB per database). Injects DATABASE\_URL and ConnectionStrings\_\_Default so a .NET app reads it with GetConnectionString("Default") and no configuration code. Paid plans only.
    
-   ### MongoDB (mongo)
    
    Your own database and user on the shared Percona Server for MongoDB cluster. Injects MONGODB\_URI. Paid plans only.
    
-   ### Valkey (valkey)
    
    A Redis-compatible key-value store. Injects REDIS\_URL and VALKEY\_URL (same value). You get your own login and a key prefix; other projects cannot read your keys, and nobody can flush the shared server.
    
-   ### Object storage (bucket)
    
    An S3-compatible bucket on the platform. Injects AWS\_ACCESS\_KEY\_ID, AWS\_SECRET\_ACCESS\_KEY, AWS\_ENDPOINT\_URL, AWS\_BUCKET (and BUCKET), and sets Laravel's FILESYSTEM\_DISK to s3 so uploads leave the ephemeral container. Your login can only reach your own bucket — not another project's, and not the platform's.
    
-   ### OpenID Connect (oidc)
    
    A client on the platform identity provider. Injects OIDC\_ISSUER\_URL, OIDC\_CLIENT\_ID and OIDC\_CLIENT\_SECRET.
    
-   ### Outgoing email (mail)
    
    Send email from your app over SMTP through the platform's relay. Injects MAIL\_HOST, MAIL\_PORT, MAIL\_USERNAME, MAIL\_PASSWORD, MAIL\_FROM, MAIL\_ENCRYPTION=tls and MAIL\_MAILER=smtp (Laravel reads them as they are), and the SMTP\_\* spelling Node, Go, Python and self-hosted apps read: SMTP\_URL (smtp://user:password@host:port, credentials percent-encoded; STARTTLS is negotiated, so use smtp:// and not smtps://), SMTP\_HOST, SMTP\_PORT, SMTP\_USER, SMTP\_USERNAME, SMTP\_PASSWORD and SMTP\_FROM. An app whose setup screen says to set SMTP\_URL needs nothing else: add the addon and redeploy. You can only send as the address the addon issued (SMTP\_FROM). STARTTLS is required and verifies with the system defaults; no CA file to configure.
    
-   ### SMS (your own provider account) (sms)
    
    Connect your own account at Twilio, Plivo, Telnyx, Netgsm, İleti Merkezi or Verimor. nesly sends nothing: it keeps your provider credentials sealed and injects the names the provider's SDK reads, plus SMS\_PROVIDER, SMS\_API\_URL and SMS\_SENDER, and SMS\_USER / SMS\_PASSWORD / SMS\_API\_KEY / SMS\_API\_SECRET where the provider has them. Add with nesly addon add sms --provider <name> --sender <title>. Per-provider names and the Turkish rules are below.
    
-   ### Email through your own provider (HTTPS API) (mailapi)
    
    Connect your own account at Resend, SendGrid, Postmark, Mailgun, Amazon SES, Gmail or Microsoft 365 (Graph) and send through the provider's HTTPS API. nesly sends nothing: it keeps your API key sealed and injects the names the provider's SDK reads, plus MAIL\_PROVIDER, MAIL\_API\_URL and MAIL\_FROM. This is not the relay above: provider SMTP ports are closed from your app, and the relay is the SMTP path. Both inject MAIL\_FROM, so a project has one of the two. Add with nesly addon add mailapi --provider <name> --sender <from>.
    
-   ### WhatsApp Business (your own Meta app) (whatsapp)
    
    Connect your own WhatsApp Business Cloud API. nesly sends nothing: it keeps your token sealed and injects WHATSAPP\_TOKEN, WHATSAPP\_PHONE\_NUMBER\_ID, WHATSAPP\_BUSINESS\_ACCOUNT\_ID, WHATSAPP\_VERIFY\_TOKEN, META\_APP\_SECRET and WHATSAPP\_API\_URL. Add with nesly addon add whatsapp --credentials-file -. App Review, Business Verification and the 24-hour template rule are yours; see below.
    
-   ### SIP (the platform's SBC) (sip)
    
    A SIP account on the platform's own session border controller, for a SIP stack inside your app. Add with nesly addon add sip. Injects SIP\_URI, SIP\_USERNAME, SIP\_PASSWORD, SIP\_DOMAIN, SIP\_TRANSPORT=tls and SIP\_PROXY. Your stack registers over TLS to SIP\_PROXY; the media stays on the platform, so your app opens no UDP port. Limits per project: concurrent calls and call minutes per day; international and premium-rate numbers are blocked.
    
-   ### AI model (model)
    
    An OpenAI-compatible API to an open model the platform runs in its own region. Add with nesly addon add model <id> (nesly models list shows the catalog). Injects NESLY\_AI\_BASE\_URL, NESLY\_AI\_API\_KEY and NESLY\_AI\_MODEL, and OPENAI\_BASE\_URL/OPENAI\_API\_KEY unless the project sets its own. Priced per token — see AI models.
    

## SMS through your own provider

nesly does not send SMS and does not resell it. You bring your own account at a provider; the addon stores its credentials and gives your code the variable names the provider's SDK already reads. Your code calls the provider's HTTPS API itself.

Pass the credentials on standard input, not on the command line (a value written on the command line is visible in the process list and your shell history):

```
printf 'NETGSM_USERCODE=…\nNETGSM_PASSWORD=…\n' | nesly addon add sms --provider netgsm --sender MARKA --credentials-file - --yes
```

Every provider gets `SMS_PROVIDER`,`SMS_API_URL` (the provider's HTTPS API base) and`SMS_SENDER`. Only the roles a provider has are injected:`SMS_USER` and`SMS_PASSWORD` for an account/password pair,`SMS_API_KEY` and`SMS_API_SECRET` for a key (and hash).

| \--provider | Names the provider's SDK reads | Platform names beyond the three | \--sender is | SMS\_API\_URL |
| --- | --- | --- | --- | --- |
| `twilio` (Twilio) | TWILIO\_ACCOUNT\_SID, TWILIO\_AUTH\_TOKEN | SMS\_USER (account SID), SMS\_PASSWORD (auth token) | a Twilio number in E.164 form, or an alphanumeric sender ID | `https://api.twilio.com` |
| `plivo` (Plivo) | PLIVO\_AUTH\_ID, PLIVO\_AUTH\_TOKEN | SMS\_USER (auth ID), SMS\_PASSWORD (auth token) | a Plivo number or a registered sender ID | `https://api.plivo.com` |
| `telnyx` (Telnyx) | TELNYX\_API\_KEY | SMS\_API\_KEY (the API key) | a Telnyx number or an alphanumeric sender ID | `https://api.telnyx.com` |
| `netgsm` (Netgsm) | NETGSM\_USERCODE, NETGSM\_PASSWORD | SMS\_USER (usercode), SMS\_PASSWORD | a sender title registered on your Netgsm account (3-11 characters) or your subscriber number | `https://ext-api.netgsm.com.tr` |
| `iletimerkezi` (İleti Merkezi) | ILETIMERKEZI\_API\_KEY, ILETIMERKEZI\_API\_HASH | SMS\_API\_KEY (key), SMS\_API\_SECRET (hash) | a sender title approved in the İleti Merkezi panel (at most 11 characters; APITEST while you wait for approval) | `https://api.iletimerkezi.com` |
| `verimor` (Verimor) | none: Verimor publishes no SDK variable names, so only the SMS\_\* names exist | SMS\_USER (username), SMS\_PASSWORD | a sender title registered with Verimor (source\_addr) | `https://sms.verimor.com.tr` |

A variable you already set yourself (say `TWILIO_AUTH_TOKEN`) is never overwritten: the add is refused and names it, so you remove yours first. Run the command again with new credentials to replace them, or to move to another provider. Previews never get your SMS account.

### Where the messages come from

Your app has no address of its own. The provider sees the platform's outbound address, shared by projects, and it can change; a provider setting that only accepts calls from fixed IP addresses will not work with it. The addon never calls the provider: it does not check your credentials, and the provider answers on first use.

### Turkey: İYS and sender titles

-   **İYS.** A commercial message (a promotion, a campaign) needs consent you collected beforehand and registered with İYS. Messages with no promotion in them (an order, a delivery, a payment, a one-time code, an account notice) are exempt. Whether a message is commercial is for you, the sender, to decide, and the fields that say so (`iys`/`iysList` at İleti Merkezi, `iysFilter` at Netgsm, `is_commercial` at Verimor) are set by your code. nesly does not query İYS and does not read your messages.
-   **Sender titles.** BTK rules in force from 1 April 2026: an alphanumeric title is 3 to 11 characters, cannot be only digits and cannot look like a phone number; a bulk message cannot be sent from a subscriber number; the title needs proof of your name, brand, domain or authority. The addon refuses a Turkish-provider title outside 3-11 characters and cannot know whether the provider has registered it: that is the provider's answer.

## Voice through your own provider

nesly carries no call and sells no telephony. You bring your own account at a provider; the addon stores its credentials and gives your code the variable names the provider's SDK already reads. Your code starts a call with the provider's HTTPS API, and the provider asks your app what to do with a call by calling your app's own HTTPS URL, the webhook. The audio (media) stays at the provider: nothing here opens a SIP or RTP port, and no `SIP_*` variable is injected.

```
printf 'TWILIO_ACCOUNT_SID=…\nTWILIO_AUTH_TOKEN=…\n' | nesly addon add voice --provider twilio --caller-id +15557122661 --credentials-file - --yes
```

Every provider gets `VOICE_PROVIDER`,`VOICE_API_URL`,`VOICE_CALLER_ID` and`VOICE_WEBHOOK_SECRET`. A provider with an account and a secret also gets `VOICE_API_KEY` and`VOICE_API_SECRET`; a provider with one key only the first.

| \--provider | Names the provider's SDK reads | Platform names beyond the four | \--caller-id is | VOICE\_API\_URL |
| --- | --- | --- | --- | --- |
| `twilio` (Twilio Voice) | TWILIO\_ACCOUNT\_SID, TWILIO\_AUTH\_TOKEN, TWILIO\_CALLER\_ID | VOICE\_API\_KEY (account SID), VOICE\_API\_SECRET (auth token) | required: a Twilio number or verified number in E.164 form | `https://api.twilio.com` |
| `verimor` (Verimor Bulut Santral) | VERIMOR\_SANTRAL\_API\_KEY | VOICE\_API\_KEY (the santral API key) | optional: an outbound number of your santral (90850…); without it the extension's own is used | `https://api.bulutsantralim.com` |
| `plivo` (Plivo) | PLIVO\_AUTH\_ID, PLIVO\_AUTH\_TOKEN | VOICE\_API\_KEY (auth ID), VOICE\_API\_SECRET (auth token) | required: a Plivo number in E.164 form | `https://api.plivo.com` |
| `netgsm` (Netgsm Netsantral) | NETGSM\_USERCODE, NETGSM\_PASSWORD | VOICE\_API\_KEY (usercode), VOICE\_API\_SECRET (password) | required: an outbound number of your Netsantral (the trunk) | `https://crmsntrl.netgsm.com.tr` |

### The webhook

The webhook URL you give the provider is your app's own HTTPS URL (for example`https://myapp.example/voice/answer`); the platform's router terminates TLS and forwards to your app like any request. Check that a request really comes from the provider before you act on it. Twilio signs every webhook:`X-Twilio-Signature` is the base64 of an HMAC-SHA1, keyed with your auth token (`TWILIO_AUTH_TOKEN`), over the full URL Twilio called followed by each POST parameter name and value, sorted by name. A Turkish santral (Verimor, Netgsm) does not sign: put `VOICE_WEBHOOK_SECRET` in the URL you register (`?secret=…`) and refuse a request without it. `VOICE_WEBHOOK_SECRET` is generated when you do not pass one as a credential, and it is kept when you add the addon again, so the URL you registered at the provider keeps working.

### Start a call

-   **Twilio:** `POST /2010-04-01/Accounts/<SID>/Calls.json` with HTTP Basic (SID, token) and form fields `To`, `From` (`VOICE_CALLER_ID`) and `Url` (your webhook that returns TwiML).
-   **Verimor Bulut Santral:** `POST /originate?key=<key>` with `extension` (the extension that rings first) and `destination`, optionally `caller_id`; the answer is the call's UUID. The older `GET /originate` closes on 31 December 2026; use POST.

A variable you already set yourself is never overwritten: the add is refused and names it. The same provider account may sit in both the `sms` and the `voice` addon (Twilio's `TWILIO_ACCOUNT_SID` and`TWILIO_AUTH_TOKEN` are then injected once, with one value); two different accounts behind the same name are refused and the refusal names the variable. Previews never get your voice account. The provider sees the platform's shared outbound address, not one of your own; the addon never calls the provider.

## Email through your own provider

nesly does not send this mail and does not resell it. You bring your own account at a provider; the addon stores its key and gives your code the variable names the provider's SDK already reads. Your code calls the provider's HTTPS API itself. Provider SMTP ports (25, 465, 587, 2525) are not reachable from your app, so only the HTTPS API works; if you want SMTP, the `mail` addon is the platform's own relay. The two are different addons: `addon add mail` keeps meaning the relay, and both inject `MAIL_FROM`, so a project holds one of them (the second is refused and names the clash).

```
printf 'RESEND_API_KEY=re_…\n' | nesly addon add mailapi --provider resend --sender hello@acme.com --credentials-file - --yes
```

**Gmail and Microsoft 365.** Both are your own app registration; the platform does not lend one. For Gmail you create an OAuth client in your own Google Cloud project, register this platform's redirect URI on it (`<API host>/oauth/mailapi/gmail/callback`), then press the consent button in the console's connection dialog once: you grant `gmail.send` and the refresh token goes straight into the sealed store. Google treats `gmail.send` as a sensitive scope: an app in production needs Google's OAuth verification, while an app left in testing mode works for the test users you list (its refresh token expires after seven days, so testing mode suits a trial, not a live site). `--sender` is the bare mailbox address, not a display name. For Microsoft 365 you register an Entra app, add the`Mail.Send` application permission and have a tenant admin grant consent; you pass tenant id, client id, client secret and the sender mailbox. An application permission lets the app send as any mailbox in the tenant unless you limit it (Exchange RBAC for Applications). Exchange Online is retiring basic SMTP AUTH, so Graph is the way to send from Microsoft 365. Request shapes:[users.messages.send](https://developers.google.com/workspace/gmail/api/reference/rest/v1/users.messages/send),[user: sendMail](https://learn.microsoft.com/en-us/graph/api/user-sendmail).

Every provider gets `MAIL_PROVIDER`,`MAIL_API_URL` (the provider's HTTPS API base) and`MAIL_FROM` (the --sender address). The sender must be an address your provider account has verified; DNS verification of the domain is yours, at the provider.

| \--provider | Names the provider's SDK reads | Notes | MAIL\_API\_URL |
| --- | --- | --- | --- |
| `resend` (Resend) | RESEND\_API\_KEY | POST /emails, Bearer key. Sending from your own domain needs the domain verified in Resend. | `https://api.resend.com` |
| `sendgrid` (SendGrid) | SENDGRID\_API\_KEY | POST /v3/mail/send, Bearer key. Needs a verified sender identity or domain authentication (CNAME records). | `https://api.sendgrid.com` |
| `postmark` (Postmark) | POSTMARK\_SERVER\_TOKEN | POST /email, header X-Postmark-Server-Token. Needs a confirmed sender signature or domain. | `https://api.postmarkapp.com` |
| `mailgun` (Mailgun) | MAILGUN\_API\_KEY, MAILGUN\_DOMAIN, MAILGUN\_BASE\_URL | POST /v3/<domain>/messages, Basic auth (api:key). For the EU region pass MAILGUN\_BASE\_URL=https://api.eu.mailgun.net with the credentials; it becomes MAIL\_API\_URL too. | `https://api.mailgun.net` |
| `ses` (Amazon SES) | AWS\_ACCESS\_KEY\_ID, AWS\_SECRET\_ACCESS\_KEY, AWS\_REGION | SigV4-signed HTTPS (the AWS SDK does this). The AWS\_\* names are the ones the bucket addon injects too, so a project cannot hold both: the add is refused and names the clash. New SES accounts start in the sandbox (verified recipients only). | `https://email.{region}.amazonaws.com` |
| `gmail` (Gmail API) | GMAIL\_SENDER, GOOGLE\_CLIENT\_ID, GOOGLE\_CLIENT\_SECRET, GOOGLE\_REFRESH\_TOKEN | POST /gmail/v1/users/me/messages/send with a base64url RFC 5322 message, OAuth 2.0 scope gmail.send. The Google OAuth client is yours; the panel runs the consent once and keeps the refresh token sealed. Google publishes no variable names for it, these are the platform's. See the Gmail and Microsoft 365 notes below. | `https://gmail.googleapis.com` |
| `graph` (Microsoft 365 (Graph)) | GRAPH\_SENDER, AZURE\_TENANT\_ID, AZURE\_CLIENT\_ID, AZURE\_CLIENT\_SECRET | POST /v1.0/users/{sender}/sendMail, Mail.Send application permission, client credentials; answers 202 with no message id. AZURE\_\* are the names Azure.Identity's EnvironmentCredential reads. | `https://graph.microsoft.com` |

A variable you already set yourself is never overwritten: the add is refused and names it. Run the command again with new credentials to replace them. Previews never get your mail account. The addon never calls the provider; it answers on first use. Your app has no address of its own: the provider sees the platform's shared outbound address.

## WhatsApp Business through your own Meta app

nesly does not send WhatsApp messages. You bring your own Meta app and WhatsApp Business Account; the addon stores its credentials and injects names (Meta publishes no official variable names, so these are the platform's). Your code calls the Graph API itself:`POST $WHATSAPP_API_URL/<version>/$WHATSAPP_PHONE_NUMBER_ID/messages`with `Authorization: Bearer $WHATSAPP_TOKEN`.

```
printf 'WHATSAPP_TOKEN=EAA…\nWHATSAPP_PHONE_NUMBER_ID=106540352242922\nMETA_APP_SECRET=…\n' | nesly addon add whatsapp --credentials-file - --yes
```

-   `WHATSAPP_TOKEN`: a system-user access token with `whatsapp_business_messaging`. Required.
-   `WHATSAPP_PHONE_NUMBER_ID`: the numeric id of the phone number (not the number itself). Required.
-   `WHATSAPP_BUSINESS_ACCOUNT_ID`: needed only to manage templates and numbers. Optional.
-   `WHATSAPP_VERIFY_TOKEN`: the string you type into Meta's webhook dialog. Optional: if you give none, neslygenerates one, and adding the addon again keeps it so Meta's subscription does not break.
-   `META_APP_SECRET`: the app secret that signs webhook events. Optional, but without it your endpoint cannot verify them.
-   `WHATSAPP_API_URL`: `https://graph.facebook.com`, the Graph API base; add the version to the path.

### The webhook is your app's own URL

Meta calls your app's HTTPS address like any other request; nesly adds no path and no forwarder. Your endpoint answers the verification GET by returning `hub.challenge` when `hub.verify_token` equals`$WHATSAPP_VERIFY_TOKEN`, and checks the `X-Hub-Signature-256` header of every POST: the hex HMAC-SHA256 of the raw body keyed with `$META_APP_SECRET`, prefixed `sha256=`.

### What stays yours

-   App Review for the permissions your app needs (Advanced access) and Business Verification where you message on behalf of others.
-   The 24-hour rule: outside the customer-service window you may only send an approved message template.
-   Opt-in and content rules of WhatsApp. nesly does not read your messages.

Run the command again with new credentials to replace them. Previews never get your WhatsApp account. The addon never calls Meta; Meta answers on first use.

## SIP and voice through the platform's SBC

A tenant has no address of its own and opens no UDP port, so SIP and RTP cannot reach your app directly.nesly runs the other end: a session border controller (Kamailio for signalling, rtpengine for media) on its edge nodes. Your SIP stack registers to it over TLS, the platform anchors the media, and you never listen on UDP. Add the account with `nesly addon add sip`; it injects `SIP_URI`,`SIP_USERNAME`,`SIP_PASSWORD`,`SIP_DOMAIN`,`SIP_TRANSPORT=tls` and`SIP_PROXY` (where to send REGISTER and INVITE). The proxy's certificate is signed by the platform CA, which is already in your container's trust bundle.

-   **Your operator, your numbers.** nesly does not sell numbers or minutes. To reach the phone network you bring your own operator trunk (Verimor, Netgsm, Twilio Elastic SIP Trunking or another); it peers with the platform's SBC. Operator trunk peering is not open yet: today the account places calls to other accounts on the platform. Providers that offer an HTTPS API and webhooks instead (Twilio Voice, Verimor Bulut Santral, Netgsm Netsantral) need no SBC; use their API from your code.
-   **Limits, per project.** A cap on concurrent calls and a cap on call minutes per UTC day, both counted by the platform, not by your code. A single call also has a maximum length. These are set low on purpose: a leaked SIP password must cost a bounded number of minutes.
-   **Blocked by default.** International destinations (numbers starting with `+` or`00`) and premium-rate numbers (Turkey's 0900, and the international premium-rate and satellite ranges) are refused with a 403. Repeated failed sign-ins from one source are refused outright. Unusual use is flagged for a person at the platform to look at; nothing is suspended automatically.
-   **Emergency calls.** Calls to emergency numbers (112) are not supported through this account. Do not use it for anything that must reach emergency services.
-   **Your stack must keep the connection.** Calls to your account come back over the TLS connection it registered on, so keep that connection open and register again after a drop.

Licences: the SBC runs Kamailio (GPL-2.0) and rtpengine (GPL-3.0) as separate services; they are not linked into your app or into the platform's own code.

## External databases (bring your own)

A store that is not in the addon catalog is not provisioned by nesly. Point your app at your own host or a third-party provider with `nesly env set DATABASE_URL=…` (or the variable your framework reads). The platform does not patch or back up that database — you (or your provider) do. Managed catalog addons remain listed above.

## Key prefixes on Valkey

Write keys under your project id, for example `prj_…:session:…`. The platform refuses keys outside that prefix and refuses dangerous server commands such as FLUSHALL. When the shared server is full, writes return an error instead of silently deleting another project's data.

## How mail leaves

Messages go out under the platform's sending address, named for your project: `"<project> via nesly"`. If your app sets its own From (say support@yourdomain), it becomes the Reply-To, so replies reach you. Each project can reach 200 recipients a day and 50 per message; past that the relay refuses with a message that says so. It is for transactional mail — sign-up, password reset, receipts — not newsletters. Port 25 stays closed: the relay is the only way out.

Nightly copies and restore: see [backups & commands](/docs/backups/). Full command list: [nesly CLI](/docs/cli/).

---
Canonical: https://nesly.net/docs/addons/
Markdown: Accept: text/markdown on the HTML URL, or replace the trailing slash with .md
