Skip to main content
theStacc MCP connects an AI client to a theStacc project for content and SEO work. Choose the project and permissions before letting the assistant act. Reading a plan, generating a draft and publishing a post are different operations; grant only the access needed for the task and review the resulting content in theStacc. The tool catalogue covers blogs, social posts, Google Business Profile, keywords, analytics and site audits. Availability depends on permissions and the service response. Use the MCP Tools Reference for parameters and limits rather than relying on a fixed tool count.

Two ways to connect

Choose a hosted connection or a local MCP process

ConnectionWhat you configureWhere it runs
Hosted sign-inAdd 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 keyConfigure the @thestacc/mcp-server package with your private THESTACC_AGENT_KEY.A local MCP process launched by your client.
Hosted sign-in creates a scoped project agent key through the authorization-code flow. Local setup supplies a key you created separately. Check that your client supports the chosen transport and configuration format; these are two connection paths, not a promise that every client supports both.

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.
Pending consent requests expire after the configured 10 minutes. If the link expires or was already answered, start a new connection request from the client. The authorization code issued after consent has its own expiry; an expired or reused code is not a reusable login link. The resulting key is labelled 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

AreaReadWrite or publish
Blogblog:readblog:write, blog:publish
Socialsocial:readsocial:write, social:publish
Google Business Profilegbp:readgbp:write, gbp:publish
SEO and keywordsseo:readseo:write, keywords:write
Choose the scopes needed for your task. Do not infer that a publishing scope automatically grants writing or reading: review the actual granted set. For a missing permission, inspect the reported 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 with sk_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 a mcpServers configuration; replace the placeholder with your generated private key:
Restart or refresh the client after changing its local configuration. Inspect the connection with 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 problemNext step
unauthorized or invalid_tokenReconnect the hosted client, or replace a lost, invalid or revoked local key.
missing_scopeReview the required scope and authorize a connection with appropriate access.
not_approved, approval_stale or approved_by_assistantA person should review and approve the blog in the app before publishing.
images_would_be_removedKeep the existing images or explicitly request an intentional removal, then check the result.
Version conflictRead the latest item and reconcile the change instead of blindly resending an old edit.
upstream_timeout or network_errorInspect the item or job before repeating the call; a lost response does not establish that no work happened.
rate_limited, validation_error or too_largeFollow the returned limit or field explanation. Waiting does not fix an invalid value or an oversized upload.
For asynchronous work, use the status tool indicated by the response rather than starting the same generation again. The tools reference covers individual inputs and recovery details. Do not treat a timeout setting as a promised generation or publication duration.

Agent key vs. Public Blog API key

The hosted MCP expects an agent-key bearer token beginning with sk_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.