Volanea’s MCP server exposes 23 tools, from get_project_status to create_workflow and send_test_email. That gives a coding agent useful ways to configure and test email, but choosing the right credential and deciding which actions need a person’s review still matter.

Email MCP server permissions define how an agent authenticates, which project it connects to, and which tools its host makes available. We recommend mapping each agent task to specific tools and a test or live credential before connecting it. That turns “email access” into a reviewable setup with clear boundaries.

What email mcp server permissions control

Think of permissions as three connected layers: the credential, the MCP server’s available actions, and the AI host’s tool policy. A project key or OAuth token authenticates the connection; the server exposes tools; and the host can decide which tools an agent may call and when a person must approve an invocation.

These layers solve different problems. Hiding a tool in a client reduces what the agent can call through that client, while a credential’s authority determines what it can access if used elsewhere. A secure setup considers both, rather than treating a sign-in method as the entire permission model.

LayerWhat it determinesVolanea example
CredentialWhich project and mode the connection usesProject API key or OAuth sign-in with project and test/live-mode selection
MCP toolsWhich documented actions the server exposescreate_template, setup_domain, send_test_email
Client policyWhich tools the agent can invoke and when to promptHost rules can require confirmation before a tool call
Application runtimeWhether deployed code can send live messagesA server-side application can use a live key after deployment

The MCP authorization specification defines HTTP authorization behavior, including how clients and servers handle access tokens. It does not replace the need to understand the specific tools and credentials in an email integration.

Volanea’s 23 tools and their practical jobs

We group the 23 tools into Orient, Build, Deliver, and Verify. This structure lets an agent first understand a project, then prepare email configuration, and finally test or inspect results. Our MCP documentation describes the groups and tools; the names below are useful examples for planning a task.

  • Orient: get_project_status, get_api_reference, list_resources provide project context and reference information.
  • Build: create_template, create_segment, create_workflow, update_workflow, create_campaign_draft handle configuration and draft creation.
  • Deliver: setup_domain, create_webhook_endpoint prepare sending and event infrastructure.
  • Verify: send_test_email, check_delivery, track_event, test_workflow support testing and delivery checks.

The distinction between a draft and a live action is useful in ordinary engineering work. For example, an agent can create a campaign draft for a launch announcement, while a person reviews its audience and content before launch. A workflow created through MCP starts paused, so it can be inspected before activation.

We provide the MCP server on every plan, and every feature ships on every plan. Plans differ by monthly volume and domain count, not by feature access. That lets a team design its tool policy around the task and environment rather than selecting a plan to unlock a particular MCP action.

Where the documented permission boundaries end

Our documentation describes a narrower MCP surface than the REST API, but it does not publish a per-tool permission matrix. It also does not document MCP restrictions by operation, email account, sender, or recipient. The docs identify two specific human-control gates: campaigns are created as drafts for a person to launch, and workflows start paused. They do not specify a confirmation requirement for other configuration edits; no MCP delete tool is listed. The docs also do not specify MCP-specific data access, storage, or retention limits.

That boundary is useful for designing a workflow: treat the documented draft and paused states as product behavior, then set any additional approval prompts in the MCP host your team uses. For example, require a person to review a template edit before merging the associated application change, and require an authorized operator to launch a campaign. Client prompts and review processes complement the server’s documented behavior; they are separate controls.

MCP also has general safety guidance. The specification says hosts should show which tools are exposed, visibly indicate tool invocations, and present confirmation prompts for operations, with a human able to deny calls. It says tool descriptions should be treated as untrusted unless they come from a trusted server. We use those principles as a practical reason to inspect tool calls rather than letting an agent’s description of its own action stand in for review.

Choose the credential for the agent’s task

Volanea documents three project API key types. Their differences are about access and delivery behavior, not a menu of fine-grained permissions.

  • sk_… is a secret key with full access to every endpoint. Keep it server-side.
  • sk_test_… has the same endpoint access, but messages render and log without delivery, and domain verification is not enforced. API responses include testMode: true.
  • pk_… is accepted only by POST /v1/events, making it appropriate for client-side product-event tracking rather than general email sending.

For a development task that creates a template and tests its rendering, use an sk_test_… key with the MCP connection. Do not treat it as read-only: it has the same endpoint access as the secret key, even though messages do not deliver. For a live application, keep the sk_… key in a server-side secret store or environment variable. Never put it in browser JavaScript, a mobile app bundle, a public environment variable, a repository commit, or an agent-chat screenshot.

A separate API detail matters when an agent writes sending code. The general POST /v1/send API accepts one message addressed to one recipient or up to 50 recipients; a separate batch endpoint supports larger personalized sends. That is an API sending limit, not a documented MCP permission to contact particular recipients. Our MCP transactional email guide explains the server-side application pattern and key handling.

How OAuth works with Volanea MCP

Volanea supports project API key authentication and OAuth for MCP clients that implement the authorization specification. In the OAuth flow, the client opens a browser for Volanea sign-in, then the user selects a project and test or live mode. Our server advertises protected-resource metadata at /.well-known/oauth-protected-resource/mcp and supports dynamic client registration, Client ID Metadata Documents, PKCE with S256, refresh tokens, and revocation.

An OAuth token represents the same tools, limits, and safety rules as a key. OAuth changes how the client obtains and manages its credential; it does not create separate read-only, campaign-only, or sender-specific access in this integration. Use the project and mode selection deliberately, then decide which tools to expose in the host.

The MCP HTTP authorization rules add concrete transport requirements. A client sends the access token in an Authorization: Bearer header on each request, includes the intended server’s canonical URI in the OAuth resource parameter, and does not put tokens in a URL. The server validates that a token was issued for it as the intended audience; invalid or expired tokens receive HTTP 401. These rules help ensure tokens reach the intended server.

The specification’s least-privilege guidance says clients should request only scopes needed for their intended operations. Its security guidance calls for secure token storage, recommends short-lived access tokens, and requires refresh-token rotation for public clients. These are protocol-level requirements and recommendations; the actions available to a Volanea OAuth connection remain those documented for the project.

Map a real agent task to tools and keys

Consider a developer asking an agent to prepare a password-reset email integration. The task includes checking the project, creating a template, testing it, and proposing application code. A deliberate setup maps each step to the smallest relevant tool set and keeps test behavior distinct from the eventual production send.

  1. Inspect context: expose get_project_status and get_api_reference so the agent can identify the project and implementation guidance.
  2. Prepare configuration: expose create_template for the reset message. Keep update_workflow and campaign tools unavailable unless the task actually needs them.
  3. Test safely: connect using an sk_test_… key and expose send_test_email and, where useful, test_workflow. MCP test sends are forced into test mode regardless of which key authenticated.
  4. Review the code: have a developer inspect the generated server-side handler, particularly where it reads a production key and decides when to send.
  5. Deploy deliberately: add a live sk_… key only to the application’s server-side environment after code review and deployment approval.

This example separates the agent’s configuration work from the application’s runtime authority. It also gives reviewers a concrete question: does the agent need this tool for the assigned task? If not, remove it from the host’s exposed set. Keep any live credential out of the prompt and local client configuration where the agent can read it.

For application code that retries a send request, use an Idempotency-Key. Volanea documents that repeating a request with the same key replays the stored response instead of sending again. This addresses duplicate sends caused by retries; it does not replace credential handling or human review of a release.

Keep test behavior separate from live sending

Test mode answers whether a message can be rendered and recorded without delivery. With an sk_test_… key, messages do not reach recipients, and the response includes testMode: true. Volanea’s MCP send_test_email action forces test mode regardless of the credential used to authenticate that MCP connection.

A separate path exists once the agent writes application code. A deployed server that holds a live sk_… key can send real messages when your application invokes the API. That means reviewing a safe MCP test is not the same as reviewing the code and environment that will handle signup, password reset, or billing events.

A practical release review should inspect the event that triggers a send, the recipient value passed to the API, the server-side location of the live key, and the deployment step that introduces it. When the application retries a request, an idempotency key can prevent the same operation from sending again. For campaign planning, our AI email marketing workflow guide covers staged work that pairs naturally with draft review.

Production checklist for an email agent

Before connecting an agent to a live project, write down its task in one sentence and compare the task with the credentials and tools it can reach. Review the client configuration and the application it may generate; they are different parts of the system.

  • Confirm the MCP endpoint is https://api.volanea.com/mcp and select the intended project and test/live mode.
  • Name the required tools, such as get_project_status, create_template, and send_test_email, and remove unrelated ones from the host’s available set.
  • Keep secret keys in a server-side secret store or environment variable, never in frontend code, chat, or source control.
  • Set host prompts for consequential tool calls, and make campaign launch and workflow activation explicit human steps in your operating process.
  • Review generated sending code and deployment secrets before the application receives a live key.
  • Decide who can revoke the connection or replace a credential if it is exposed or no longer needed.
  • Inspect event and delivery outputs before sharing them with an AI host, and limit the context provided to what the assigned task needs.

We also recommend recording the project, mode, exposed tools, reviewer, and release decision in the same change request or deployment record as the email integration. That gives another engineer a way to understand why a tool was made available and who approved live behavior, without relying on the agent’s conversation history.

FAQ

Can I make a Volanea MCP connection read-only?

Volanea’s documented OAuth token has the same tools, limits, and safety rules as a key; the docs do not describe a read-only role. You can limit tools exposed by your MCP host, then review the host’s configuration and credential storage. That client-side tool selection is distinct from a server-enforced read-only credential.

Is OAuth safer than putting an API key in an MCP client?

Volanea OAuth uses a browser sign-in and supports PKCE S256, refresh tokens, and revocation. The MCP specification also requires secure token storage and sets rules for token audience and transport. OAuth and keys still have the same documented Volanea tool access, so choose based on your client’s supported flow and how your team manages credentials.

What happens if a test email is sent through MCP using a live key?

The MCP send_test_email tool forces test mode even when a live key authenticated the connection. The test message renders and logs but does not deliver. A separate application deployed with a live key can still send real mail, so review the application code and deployment environment independently.

When should a team move from a test key to a live key?

Move when the server-side integration has passed rendering and workflow tests, its send triggers and recipient handling have been reviewed, and the deployment process is ready to hold a live secret. Keep the test credential for development and put the live key only in the production server environment after an authorized release decision.

A useful first step is to connect in test mode, expose only the tools needed for one task, and have a developer review the generated result before adding production credentials. We include the MCP server on every plan, so you can start with 1,000 emails a month free and expand your email workflow when you are ready.