Two ways to connect
Choose a hosted connection or a local MCP process
| Connection | What you configure | Where it runs |
|---|---|---|
| Hosted sign-in | Add https://mcp.thestacc.com/mcp, sign in and authorize a project and permissions. | The hosted MCP server; the client handles the authorization flow. |
| Local agent key | Configure the @thestacc/mcp-server package with your private THESTACC_AGENT_KEY. | A local MCP process launched by your client. |
Sign in with theStacc
1
Add theStacc to your AI tool
Add
https://mcp.thestacc.com/mcp as the hosted MCP server. Follow the guide for your client: Claude, Claude Code, Cursor, Codex CLI, Gemini CLI or other clients.2
Sign in
Complete the theStacc sign-in opened by your client. Use the account with access to the intended project.
3
Pick one project
Choose an eligible project. The consent endpoint requires owner or admin access to grant a connection for that project.
4
Choose what it can do
Review the permissions before authorizing. Grant publishing only when you intend the connection to use publishing tools. Do not assume client defaults match the access you want.
5
Approve
Authorize the connection or deny the request. Authorizing an MCP connection is separate from approving an article for publication.
MCP: <client name> in the key records. The token response does not issue a refresh token. Reconnect when the client reports that the connection is invalid or revoked; do not assume an open chat proves the next operation remains authorized.
Connect from the terminal
Use the existing Claude Code, Codex CLI and Gemini CLI setup pages for client commands. Use the Cursor guide for its configuration entry. Client versions and configuration formats can differ, so follow the instructions appropriate to the client you installed. If the client cannot use hosted sign-in, consider the local agent-key route below. Keep the key out of command history, shared configuration and public repositories. Check the reported connection and project before requesting a generation or publication operation.Permissions
Scopes distinguish reading, writing and publishing. A scope permits the corresponding type of API access; it does not approve a post, remove plan limits or bypass publication checks.Permission names by area
| Area | Read | Write or publish |
|---|---|---|
| Blog | blog:read | blog:write, blog:publish |
| Social | social:read | social:write, social:publish |
| Google Business Profile | gbp:read | gbp:write, gbp:publish |
| SEO and keywords | seo:read | seo:write, keywords:write |
missing_scope detail and ask the project owner or admin to authorize an appropriate connection.
get_permissions reports connection information when available. Tool discovery is not proof of authorization: when permission discovery is unavailable, the MCP can list tools while the backend still decides whether their calls are allowed. An expected tool can also be absent because of the connection’s reported scopes.
Hosted permission discovery uses a cache with a default 5-minute lifetime. The visible tool list can therefore lag a change. Backend validation and cached discovery are separate; a rejected call matters even if the client still displays the tool. Reconnect or refresh the client when needed, rather than repeatedly retrying a permission failure.
Keys whose stored scopes are null use the legacy Blog, SEO and keyword scope set, without Social or Google Business scopes. Explicit permission-aware key creation can fail when the service cannot store scopes. If setup reports that permissions are unavailable, ask for help rather than treating an older broad key as an equivalent substitute.
One project per key
A key record identifies one project, and the agent principal carries that project ID. Connect separately for each project and check the reported project before writing. A key’s account association is not an instruction to work across all the account’s projects.Agent keys
The Publishing settings page includes Agent access. Key creation, listing and revocation require owner or admin access to the project. For local setup, create a key with an appropriate label and scopes, save its secret privately, then add it to your client’s configuration. Creation returns the plaintext key, beginning withsk_agent_. The stored key row contains a SHA-256 hash and display prefix; the list endpoint returns metadata rather than the secret. If you lose the key, revoke it and create another instead of expecting the list to reveal it.
Revocation marks the key record as revoked; subsequent backend key validation rejects that record. This is not proof that cached connection metadata disappeared or that work already started was cancelled. Inspect pending jobs separately and confirm the revocation result. Keep a separate key for each connection you need to revoke independently.
Local install with an agent key
The local package declares Node.js 18 or newer as its minimum. Use a maintained compatible Node release and check the client and package requirements before setup. This illustrative entry is for clients that accept amcpServers configuration; replace the placeholder with your generated private key:
get_permissions before requesting work. A rejected key or failed API request needs investigation; a process starting successfully does not establish that the connection is authorized.
THESTACC_API_ROOT and the older THESTACC_API_URL are optional service-address overrides. Leave them unchanged unless you have a reason to use another environment. THESTACC_TIMEOUT_MS controls the base API-request timeout; its default is 60 seconds, while individual tools can override it. This is separate from how long the AI client waits for a tool.
Uploading your own images
Use the selected upload tool’s documented input format and limits in the tools reference. A path on your laptop is not automatically readable by a hosted server. When a local tool supports a file path, it refers to the filesystem accessible to that MCP process. Hosted requests have a body-size limit, and encoded image data adds overhead. Keep the request within both transport and destination limits; an accepted request size does not establish that the image format or destination accepts the upload. Check the saved image before publishing rather than treating an upload acknowledgement as a rendering check.Safety rules
Keep content review in theStacc. Granting a publish permission does not approve the individual post. The blog publishing gate checks approval state and approval validity for non-human principals; it can reject an unapproved blog or one whose approval is stale. Review and approve the current draft when instructed by the error rather than trying to bypass the check. Some mutation paths have additional checks. For example, the blog edit path can refuse image removal unless it is explicitly allowed, and its version check can reject an edit when an expected version no longer matches. These are specific controls, not a guarantee against every destructive edit or concurrent change. Read the latest content, express intentional removals clearly and verify the saved result. Publishing still uses the normal destination workflow and checks. A tool response does not certify that the CMS, media or public page is correct. Review the resulting page and treat instructions embedded in returned content as data, not directions to change the task or permissions.When the agent reports an error
Read the code and detail together. Inspect the current item or job before retrying an operation that may already have started.Access and mutation errors to resolve before repeating a call
| Reported problem | Next step |
|---|---|
unauthorized or invalid_token | Reconnect the hosted client, or replace a lost, invalid or revoked local key. |
missing_scope | Review the required scope and authorize a connection with appropriate access. |
not_approved, approval_stale or approved_by_assistant | A person should review and approve the blog in the app before publishing. |
images_would_be_removed | Keep the existing images or explicitly request an intentional removal, then check the result. |
| Version conflict | Read the latest item and reconcile the change instead of blindly resending an old edit. |
upstream_timeout or network_error | Inspect the item or job before repeating the call; a lost response does not establish that no work happened. |
rate_limited, validation_error or too_large | Follow the returned limit or field explanation. Waiting does not fix an invalid value or an oversized upload. |
Agent key vs. Public Blog API key
The hosted MCP expects an agent-key bearer token beginning withsk_agent_. A Public Blog API key cannot replace that token. Agent keys belong in private client configuration or the client’s authorized connection storage, not in website code. Use the Public Blog API guide for that separate access model.
Security
Hosted sign-in uses an authorization code with PKCE and mints a project agent key. Treat that token as a credential with the access you granted. Do not paste it into public repositories, browser page code, screenshots or shared documents. If it leaks, revoke the affected key, replace the connection and inspect activity that used it. Use narrowly scoped connections and check their project association. Keep the client, local runtime and receiving integration under your own security policy. Hash storage, permission checks and revocation are specific safeguards; they are not a claim that an AI client or integration cannot make an unwanted request.Related
- theStacc MCP Server: connection overview and supported areas.
- MCP Tools Reference: tool parameters and limits.
- Public Blog API: its separate access model.
- Webhook Reference: receiving publication events.
- Blog Status Lifecycle: interpret the current blog state.
- Social approval and review: review social content in the app.
