A software statement is a signed JWT that tells an OAuth server who a client is, and what it is allowed to reach, at the moment it registers. viaNexus uses one so an agent can register itself dynamically, under RFC 7591, and come away with a token scoped to exactly the datasets you granted it. No pre-registration, no shared secret in the client, no client-side permission checks.

Why does MCP need this?
An MCP client is often not a person at a browser. It might be an agent on a server, a background job, or code running on someone else's machine. Static client credentials do not fit that: you cannot pre-register every agent, and you should not ship a secret inside one.
Dynamic client registration solves the first half, the client registers itself when it starts. The software statement solves the second half, because it is signed by us, carries the permissions, and expires.
How do I get a software statement?
Ask the API for one with your viaNexus token, and say what the agent should be allowed to see:
POST https://api.blueskyapi.com/v1/agents/register?token=$VIANEXUS_API_TOKEN
Content-Type: application/json
{
"expiresIn": "1h",
"permissions": {
"include": ["EDGE:MT_NEWSWIRES*"],
"exclude": ["CORE:*"]
}
}You get back a signed JWT carrying the contact, software ID, payload ID, the dataset permission patterns, and an expiry. Your API token is kept server side for the exchange, it is not embedded in the JWT.
If you are signing in through a hosted flow instead, like the Claude connector, the console creates the statement for you after login and you never handle it directly.
How does the OAuth flow use it?
- Register. The client posts the statement to the auth server:
POST /registerwith{"software_statement": "$VIANEXUS_JWT"} - Authorize. Standard authorization code flow with PKCE, so the exchange is protected even on a public client
- Token. The client swaps the code plus its PKCE verifier for a short-lived access token
The OAuth metadata lives at https://vast.blueskyapi.com/.well-known/oauth-protected-resource/vianexus/mcp, so a compliant client can discover the endpoints on its own.
Where do permissions actually get enforced?
Server side, on every call. The auth server stores the dataset permission patterns alongside the token and exposes them through introspection:
{
"active": true,
"aud": "https://vast.blueskyapi.com/vianexus/mcp",
"scope": "user",
"dataset_permissions": { "include": ["EDGE:MT_NEWSWIRES*"] },
"exp": 1746615262
}The MCP service reads that before it answers. A call for an out-of-scope dataset comes back as Permission denied for dataset CORE:REPORTED_FINANCIALS, and out-of-scope datasets do not even appear in discovery. There is no client-side filter to bypass, which matters when the thing making the calls is a model rather than your own code.
How long does everything last?
- Software statement: signed handoff artifact, one hour by default
- Access token: one hour, validated through introspection on each call
- Refresh token: 30 days, when the flow issues one. SDK clients refresh behind the scenes
How do I change what an agent can see?
Issue a new software statement with different permission patterns, or change the subscription behind the token. The client code does not change and nothing gets redeployed. That is the point of putting permissions in the statement rather than in the agent.
Next
- The viaNexus MCP server, the endpoint and what it exposes
- MCP Permissions for Financial Data, why we built it this way
- Python Agent SDK, which handles registration and refresh for you
Related guides
- Financial Data MCP Server — What the server exposes, how to connect and what each tool does.
- Connect Claude to Live Stock Market Data — Add the viaNexus connector in Claude and start pulling quotes, earnings and news.
- Cursor MCP Setup for Financial Data — API key config, environment variables and common Cursor gotchas.