MCP Server

What Is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI assistants connect to external data sources and tools. Simply360 exposes a hosted Streamable HTTP MCP endpoint, so MCP-compatible clients can inspect your team's schema and work with your team's data through the same public API, permissions, and audit boundaries used by first-party clients.

Hosted Endpoint

Use the hosted remote MCP endpoint for the Simply360 environment you are connecting to instead of installing a local Simply360 stdio package:

Environment	MCP server URL	Availability
Production	https://api.simply360.app/v1/mcp	The default environment.
Staging	https://api.staging.simply360.app/v1/mcp	A paid add-on or an included benefit of a specific offer.
Development	https://api.dev.simply360.app/v1/mcp	A separate, limited developer-preview add-on or approved beta grant.

Access to Staging and Development is not included automatically with a production Simply360-powered app. Development is also not included with Staging. The selected Team Admin or Team User must have explicit access to the same environment as the endpoint. See Environments for the full access and credential model.

The endpoint is stateless: each MCP request is a plain HTTP POST and the response is returned as buffered JSON (there is no server-side session to resume, and GET/DELETE return 405). Per the MCP specification, clients should send Accept: application/json, text/event-stream. Supported MCP protocol versions are 2025-11-25 (default), 2025-06-18, and 2024-11-05.

Authentication

Use OAuth when your MCP client supports connector authorization. OAuth lets each Team Admin or Team User connect with their own Simply360 identity, and requested scopes are still intersected with their Simply360 feature and data permissions. MCP clients discover the OAuth configuration automatically from /.well-known/oauth-protected-resource on the API host; authorization is handled by Simply Login and supports PKCE and dynamic client registration.

Get an OAuth Client ID or Client Key Manually

Some MCP clients do not complete dynamic client registration from discovery and instead ask for an OAuth Client ID, sometimes labeled an OAuth Client Key, plus an OAuth Client Secret. These values are not a Simply360 API key. Create them from the OAuth registration endpoint for the same environment as the MCP server:

Environment	OAuth registration endpoint
Production	https://api.simplylogin.app/oauth/register
Staging	https://api.staging.simplylogin.app/oauth/register
Development	https://api.dev.simplylogin.app/oauth/register

For Claude, register its current remote-connector callback URI and request a confidential client:

S360_OAUTH_REGISTRATION_URL="https://api.simplylogin.app/oauth/register"

curl -sS -X POST "$S360_OAUTH_REGISTRATION_URL" \
  -H "Content-Type: application/json" \
  -d '{
    "client_name": "Claude",
    "redirect_uris": ["https://claude.ai/api/mcp/auth_callback"],
    "scope": "schema:read records:read records:write websites:read websites:write conversations:read conversations:write files:write wizards:run admin:read offline_access",
    "token_endpoint_auth_method": "client_secret_basic"
  }' | jq .

The registration response includes both values Claude needs:

{
  "client_id": "s360_mcp_client_...",
  "client_secret": "s360_oauth_cs_...",
  "token_endpoint_auth_method": "client_secret_basic"
}

• Put client_id in Claude's OAuth Client ID field. If another client calls the field OAuth Client Key, use this same client_id value.
• Put client_secret in OAuth Client Secret. It is returned only when the client is registered, so store it in your organization's secrets manager or complete setup immediately.
• Use the registration endpoint and MCP URL from the same environment. Never reuse a production OAuth client in Staging or Development, or a non-production client in production.
• Request only the scopes the connector needs. The example requests every currently supported hosted MCP scope; remove write or admin scopes for a narrower connector.

A public MCP client that can perform Authorization Code with PKCE without holding a secret may register with "token_endpoint_auth_method": "none". In that case the response contains a client_id but no client_secret.

For server-side or local developer tooling, clients that support remote HTTP MCP headers can authenticate with a scoped Simply360 API key:

Authorization: Bearer s360_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx

Use API keys only for server-to-server or local development workflows. Prefer OAuth for user-facing assistants. For API-key callers, route access comes from the key's explicit scoped feature permissions, and MCP record access additionally comes from the API key's selected Data Role (teamRoleSimplyId in the API Keys API), not from the key's scoped feature-permission JSON alone.

Connecting A Client

In any MCP client that supports remote Streamable HTTP servers, add a server with:

• Server URL: the production, Staging, or Development MCP URL from the table above
• Transport: Streamable HTTP
• Auth: OAuth connector flow, or an Authorization: Bearer ... header for API-key tooling

Claude

For an individual Claude plan, open Customize → Connectors, choose Add custom connector, and enter the MCP server URL. For a Claude Team or Enterprise organization, an Owner adds it under Organization settings → Connectors. If Claude does not discover and register the OAuth client automatically, open Advanced settings and paste the manually registered client_id and client_secret from the steps above. See Anthropic's custom connector setup guide for its current menu names and plan requirements.

Some local-only clients can connect to a remote MCP server through a generic remote-MCP bridge. In that case, configure the bridge with the same URL and authorization header above.

Working Across Multiple Teams

If you belong to more than one Simply360 team, one connection can cover them. On the authorization screen, pick your primary team and check any additional teams under "Also authorize these teams". The resulting connection can act on every team you selected — each request simply names the team it targets:

• MCP tools: call list_my_teams to see the teams the connection covers, then pass one of the returned teamSimplyId values as the teamSimplyId argument on every other tool call. Multi-team connections require the argument on each call (there is no implicit "active team" — the endpoint is stateless by design); single-team connections can omit it. Tool results echo the team they acted on.
• REST API: the same token may target any authorized team per request with the X-Team-Id header (or ?teamSimplyId=). Requests without a team header use the primary team.

Team membership is re-validated on every call: a team you leave stops working immediately even if it was authorized, and teams you join after connecting are not included until you re-authorize. Teams you did not select at consent are always rejected. To change the authorized set, reconnect and choose again.

Alternative: One Connector Per Team

Clients that de-duplicate connectors by exact URL (such as claude.ai) also accept the same server under team-qualified URLs, so you can instead add one connector per team and authorize each for a single team:

https://api.simply360.app/v1/mcp?teamSimplyId=TEAM_A
https://api.simply360.app/v1/mcp?teamSimplyId=TEAM_B

Each connector then carries its own single-team authorization and needs no teamSimplyId tool argument. This is the right shape when you want hard separation between teams in your client's connector list; the multi-team connection above is the recommended default.

Available Tools

The hosted server exposes a curated toolset instead of every public API endpoint, organized into seven families: data, AI record import, billing, file upload, Website Studio, signing requests, and Simply Spaces. Tool names are stable and use public Simply IDs for all entity references. Each tool requires the OAuth scope listed below (API-key callers are checked against the equivalent feature and Data Role permissions). Every tool also accepts the optional teamSimplyId team-selection argument described above.

Data Tools

Tool	Scope	Description
list_my_teams	—	List the teams this connection can act on, with the primary marked. Multi-team connections use the returned teamSimplyId values on every other tool call.
list_data_collections	schema:read	List data collections visible to the authenticated caller.
get_data_collection	schema:read	Get one data collection and its readable field definitions.
list_data_records	records:read	List records in a collection by dataCollectionSimplyId.
get_data_record	records:read	Get one record by dataRecordSimplyId.
search_data_records	records:read	Search records with metadata and custom-field filters.
create_data_record	records:write	Create a record in a collection when the caller has write access.
update_data_record	records:write	Update field values on a record when the caller has write access.
archive_data_record	records:write	Archive a record from a collection when the caller has delete/archive access.
list_data_views	schema:read	List saved data views visible to the caller.
get_data_view	schema:read	Get one data view definition by dataViewSimplyId.

AI Record Import Tools

The AI import tools mirror Ask Simply's import capability. They are proposal-handle tools (records:write): a call does not compose or create records directly. It re-checks that the caller can create (or, for undo, archive) records, then returns a proposal-control handle ({ proposalRequired: true, approvalSurface: "ASK_SIMPLY", requestedToolName, summary, riskLevel, requiredPermissions, affectedResources, arguments }). Composition (background) and the transactional graph save run only after the proposal is approved through the same Ask Simply proposal-approval path, where permissions are re-checked and the engine enforces the per-collection CREATE_DATA_RECORDS gate. The targetKey is always re-resolved server-side; discover writable collections with list_data_collections and build a generic key such as generic.auto or generic.collection.<dataCollectionSimplyId>.

Tool	Scope	Description
draft_import_records	records:write	Draft an import of a connected record graph into a resolved target from pasted text, staged attachments, and/or URLs. Returns a proposal-control handle.
draft_undo_import	records:write	Draft a reversal of a previously executed import by archiving (never hard-deleting) exactly the records it created. Returns a proposal-control handle.

DataWizard-steered "Recommended" import targets are surfaced only through Ask Simply and the first-class GET /v1/data-records/ai-graph/targets API; the hosted MCP surface intentionally exposes generic targets (discoverable via list_data_collections) rather than duplicating the service-local target registry.

Billing Tools

Read-only team billing tools. They require the admin:read scope plus the TEAM_ADMIN_BILLING feature permission:

• get_team_billing_status — selected-team billing status
• list_team_billing_invoices — invoice summaries
• get_team_billing_invoice_receipt — receipt detail for one invoice
• get_team_billing_next_invoice_estimate — preview of the next invoice, without creating charges

File Upload Tool

request_file_upload requires edit-qualified TEAM_ADMIN_MEDIA_LIBRARY permission. OAuth callers also require files:write; API-key callers have no OAuth scopes and remain constrained by their explicit feature permission. The tool returns a Simply360 browser URL for the selected team. The assistant asks the user to open that signed-in page, choose a local file, wait for quarantine scanning and promotion, and then provide the displayed public File Simply ID.

This is intentionally a human browser handoff: MCP messages and model-visible tool results never contain the local file bytes, private storage key, quarantine bucket, or presigned POST credentials. The browser uses the same checksum-bound, GuardDuty-scanned upload API as the first-party webapp. The tool is write-capable and disappears when hosted MCP write tools are disabled.

Website Studio Tools

Website Studio tools require the TEAM_WEBSITES or TEAM_ADMIN_WEBSITES feature permission in addition to website-level role permissions.

Read tools (websites:read) cover websites, templates, pages, page design and blocks, versions, comments, access areas, permissions, experiments, data resources, publish readiness, style kits, media files, background tasks, and backups: list_websites, get_website, list_website_templates, get_website_template, get_website_studio_context, list_website_pages, get_website_page, get_website_page_design, list_website_page_blocks, list_website_page_versions, list_website_comments, list_website_access_areas, list_website_permissions, list_website_experiments, list_website_data_resources, run_website_publish_readiness, list_style_kits, get_style_kit, list_media_files, get_media_file, get_website_background_task, list_website_backups, get_website_backup.

Draft (proposal) tools (websites:write) do not change a website directly. Each call records a draft proposal; the proposal is validated and executed through the Website Studio proposal workflow, where the caller's website permissions and backup requirements are re-checked at execution time. The draft tools are:

Area	Tools
Sites & pages	draft_create_website, draft_copy_website, draft_update_website, draft_delete_website, draft_create_website_page, draft_update_website_page_metadata, draft_reorder_website_pages, draft_delete_website_page
Navigation & chrome	draft_update_website_navigation, draft_update_website_header, draft_update_website_footer, draft_update_website_theme
Style kits	draft_assign_style_kit, draft_create_style_kit, draft_update_style_kit, draft_copy_style_kit
Versions & backups	draft_create_page_version_checkpoint, draft_restore_page_version, draft_create_website_backup, draft_restore_website_backup
Page design & blocks	draft_patch_website_page_design, draft_insert_website_block, draft_insert_website_layout, draft_update_website_block, draft_delete_website_block, draft_insert_data_view_block, draft_insert_data_wizard_block, draft_attach_media_to_website_block
AI-assisted rewrites	draft_rewrite_website_selection, draft_redesign_website_page, draft_redesign_website
Access & experiments	draft_create_or_update_access_area, draft_update_website_permissions, draft_create_or_update_experiment
Workflow & publishing	draft_start_website_translation, draft_submit_page_for_review, draft_request_page_changes, draft_publish_website_page, draft_publish_website_header_footer, draft_publish_website
Import	discover_external_website_pages

Signing Request Tools

• list_signing_requests, get_signing_request (records:read) — read signing requests through source-collection data permissions
• create_signing_request, resend_signing_request (records:read + records:write) — create a signing request or reissue signer links
• void_signing_request (records:write) — void an in-flight signing request

Simply Spaces Tools

• list_simply_spaces_booking_channels (schema:read, requires the SIMPLY_SPACES_VIEW or SIMPLY_SPACES_MANAGE feature permission) — list booking-channel configuration and durable link references

Write-capable tools (record writes, file-upload handoff, signing writes, and the website draft tools) can be centrally disabled; when disabled they are not advertised by the server.

Resources

The server also exposes the current team's schema as an MCP resource at simply360://team/schema (scope schema:read). This gives assistants collection and field context without requiring them to discover schema one endpoint at a time.

MCP resources take no arguments, so on a multi-team connection this resource always reflects the connection's primary team (the payload names which team it describes). To explore another authorized team's schema, use the team-scoped list_data_collections and get_data_collection tools with that team's teamSimplyId instead.

Tool Permissions

Whether a tool succeeds depends on the authenticated caller. OAuth callers are constrained by requested OAuth scopes and their Team Admin or Team User permissions. API-key callers are constrained by the key's explicit scoped feature permissions and selected Team Role data permissions. File upload requires edit-qualified TEAM_ADMIN_MEDIA_LIBRARY; Website Studio tools additionally require the TEAM_WEBSITES or TEAM_ADMIN_WEBSITES feature permission, billing tools require TEAM_ADMIN_BILLING, and Simply Spaces tools require SIMPLY_SPACES_VIEW or SIMPLY_SPACES_MANAGE. MCP never grants permissions that the caller does not already have in Simply360.

Simply Action Tags Boundary

The hosted MCP surface does not expose new standalone Action Tags mutation, CSV import, billing, payment-method, custom-domain, webhook-secret, Action Credential issuance, or credential-presentation tools. This is intentional: imports and plan changes have idempotency/customer-confirmation requirements, domains mutate external routing, and credential payloads are bearer material.

An eligible developer can use the documented Action Tags Public API or TypeScript SDK for plan-gated Action-only operations. MCP cannot bypass the 500-Action API allowance or unlock Simply360-powered record/Wizard connections. Ask Simply/TeamAgent has a separate proposal-gated Action surface.

Security Considerations

• Prefer OAuth for assistants used by individual team members.
• Treat API keys as production secrets: rotate them regularly and never commit them to source control.
• Use read-only or narrowly scoped keys for local development when write tools are not needed.
• Restrict API keys to known source IP addresses for server-side MCP clients.

Example Conversation

Once connected, an assistant can call MCP tools transparently:

User: How many contacts were added this week?

Assistant: (calls list_data_collections, picks the Contacts collection, then calls search_data_records) 23 contacts have been added in the last 7 days.