Skip to main content
Glama

partner-center-mcp

partner-center-mcp MCP server

Building against the Partner Center REST API means living in Microsoft Learn. Two hundred odd endpoint pages, an archived .NET SDK that still turns up in search results, and error codes that tell you almost nothing on their own.

This MCP server puts that knowledge next to your agent. Ask how to cancel a subscription and you get the verified method, path, headers, a working code sample, and the constraints the page actually warns about. It holds no credentials and never calls Partner Center. Every answer comes from a bundled knowledge pack, with a cached Microsoft Learn search as the fallback.

Unofficial, community project. Not affiliated with, sponsored, or endorsed by Microsoft. "Partner Center" and "Microsoft" are trademarks of Microsoft, used here only descriptively.

Why

Microsoft archived the Partner Center .NET SDK (3.4.0) in June 2023 and points partners at the REST APIs instead. Plenty of code still hasn't moved. The retired graph.windows.net audience keeps producing 401 / 900420, and from 2026-04-01 App+User API calls enforce MFA.

So the server does two things. It shows you the current REST and auth patterns, and it explains the errors you hit on the way there.

Related MCP server: weclapp-api-knowledge-mcp

How it works

Your MCP host (Claude Code, Cursor, Copilot, VS Code) talks to the server over MCP, on stdio by default or HTTP if you'd rather. The server reads from a knowledge pack that is zod-validated at load and anchored to official Learn pages. When the pack has no answer it falls back to a cached doc search.

An MCP host talks to partner-center-mcp over stdio or HTTP. The server exposes tools plus resources and prompts, answers from a zod-validated knowledge pack, falls back to a cached Microsoft Learn search, and a weekly CI job checks the pack against the docs.

A typical call: the agent picks a tool such as pc_generate_call, the server looks the scenario up in the pack, and back comes the method, path, headers, a ready code sample, and the gotchas, each carrying the docUrl it was verified against.

Run

npx partner-center-mcp

No configuration, API keys, or network access to Partner Center required.

Requires Node.js 20 or newer. (0.9.0 dropped Node 18, which reached end of life in April 2025.)

Add to your MCP host

The server speaks MCP over stdio, so any MCP-capable host works. There's nothing host-specific to install. Use whichever config your host expects:

VS Code (.vscode/mcp.json) and Visual Studio (.mcp.json):

{ "servers": { "partner-center": { "command": "npx", "args": ["-y", "partner-center-mcp"] } } }

GitHub Copilot. Copilot reads the same .vscode/mcp.json (VS Code) / .mcp.json (Visual Studio) shown above; no extra config needed.

Cursor (.cursor/mcp.json) and Windsurf (~/.codeium/windsurf/mcp_config.json):

{ "mcpServers": { "partner-center": { "command": "npx", "args": ["-y", "partner-center-mcp"] } } }

Claude Code:

claude mcp add partner-center -- npx -y partner-center-mcp

Claude Desktop (claude_desktop_config.json), Cline, and Zed use the same mcpServers shape as Cursor above.

Tip: also add the Microsoft Learn MCP server (https://learn.microsoft.com/api/mcp) alongside this one for broad documentation search.

Remote / HTTP (optional)

Prefer a hosted endpoint over stdio? Run the Streamable HTTP variant:

PORT=3000 npx -p partner-center-mcp partner-center-mcp-http
# MCP endpoint: POST http://localhost:3000/mcp   •   health: GET /healthz

The endpoint has no authentication of its own, so it binds 127.0.0.1 by default. Request bodies are capped at 1 MiB, and a browser Origin has to be loopback or explicitly allowed, which is what keeps a random web page from driving your local server.

Variable

Default

What it does

PORT

3000

Port to listen on.

HOST

127.0.0.1

Interface to bind. Set 0.0.0.0 only behind a proxy that authenticates.

ALLOWED_ORIGINS

none

Comma-separated browser origins allowed in addition to loopback.

MAX_BODY_BYTES

1048576

Largest accepted request body.

Tools

Tool

Purpose

pc_list_scenarios

List supported REST scenarios, optionally filtered by area.

pc_get_scenario

Full detail for one scenario: method, path, headers, examples, gotchas.

pc_generate_call

Emit a current REST call (curl/csharp/typescript/powershell) with auth/retry/pagination helpers. Never the archived SDK.

pc_validate_request

Lint a REST call (method, URL, headers, auth) against the known scenarios.

pc_plan_purchase

The ordered New Commerce purchase workflow: product → SKU availability → cart → checkout → subscriptions.

pc_migrate_from_sdk

Translate archived .NET SDK code into the equivalent REST scenario(s).

pc_auth_guidance

Current auth guidance for app-only / app+user, per national cloud, with GDAP + MFA notes.

pc_check_auth

Lint an auth/client snippet for retired patterns (graph.windows.net, ADAL, archived SDK, AzureAD PS).

pc_build_request

Build a ready-to-send request: fills path placeholders, generates MS-RequestId/MS-CorrelationId, and a body skeleton from the scenario's fields.

pc_explain_lifecycle

What you can do to a subscription in its current state: legal operations, the field each precondition reads, and the errors a failed precondition returns.

pc_plan_subscription_change

Ordered call sequence for one lifecycle change: seats up/down, upgrade, cancel, renewal changes, suspend, reactivate, migrate, transfer.

pc_plan_order_lifecycle

Ordered call sequence from cart to provisioned subscriptions, with the cancellation and add-on branches.

pc_plan_transfer

Ordered billing-ownership transfer workflow (create → poll → verify).

pc_plan_gdap_onboarding

Ordered GDAP onboarding workflow (create → approve → verify) over Microsoft Graph.

pc_plan_csp_onboarding

Ordered CSP customer onboarding (account linking): invite → verify relationship → confirm agreement → transact.

pc_plan_user_onboarding

Ordered user onboarding: create user → assign licenses → grant roles → verify.

pc_plan_user_offboarding

Ordered user offboarding: remove licenses → strip roles → delete user (30-day restore window).

pc_plan_reconciliation

Ordered reconciliation workflow (invoice → billed/unbilled line items → statement).

pc_lookup_error

Decode an error code: causes, remediation, and the scenarios it commonly hits.

pc_decode_error

Paste a raw error response → decoded code, likely scenarios, and the correlation id for support.

pc_diagnose

Map a symptom to likely causes, fixes, and relevant scenarios.

pc_get_enums

Look up enum values (billingCycle, termDuration, targetView, transitionType, status, …).

pc_get_resource

Field dictionary for resources (Customer, Subscription, Order, Invoice, migration schedules, …).

pc_whats_new

Deprecations & deadlines (MFA enforcement, graph.windows.net, v1→v2 reconciliation, …).

pc_plan_prerequisites

For any scenario, the ordered calls that produce the ids its path needs, and the parameters you supply yourself.

pc_diff_pack

What changed between pack releases: scenarios added, removed, or whose route, auth, fields or constraints moved.

pc_search_docs

Fetch live Microsoft Learn excerpts. The fallback when the curated pack has no answer.

pc_get_reference

Base URLs, headers, versioning, sandbox, rate limits, national-cloud differences.

Every tool carries the metadata a calling agent needs: a title, a description that says when to use it and which sibling to prefer instead, a description on every input parameter, a declared outputSchema, and MCP behaviour annotations. All 28 are readOnlyHint: true and destructiveHint: false, because the server holds no credentials and calls no Partner Center endpoint. It only reads the bundled pack. Three tools break idempotentHint or openWorldHint: pc_search_docs and pc_get_scenario with enrich: true both reach Microsoft Learn, and pc_build_request mints a fresh MS-RequestId on every call.

Responses share one envelope. { ok, data } on success, { ok: false, error, suggestions? } on failure, returned as structuredContent and validated against each tool's outputSchema by the MCP SDK.

Coverage

Scenarios cover:

  • Customers. Identity and profiles, search, users and directory roles, relationship removal, agreements and consent, self-serve policies.

  • Subscriptions. The whole lifecycle: seats up and down, upgrade, cancel, renewal changes, suspend and reactivate, add-ons, New Commerce migration, transfer.

  • Orders and carts. Through to provisioning status, not just checkout.

  • Devices. Autopilot batches and configuration policies, end to end.

  • Billing and pricing. Azure consumption usage at every level, spending budgets and overage, invoices and reconciliation line items, service costs, margins and growth margins, price sheets, the offer matrix, FX rates, and promotion eligibility.

  • Analytics. Subscription, indirect reseller, referral and search analytics, plus the three separate licence usage and deployment families.

  • Plus catalog and products, licenses, address and domain validation, audit, support, security and MFA, and partner profiles.

Every scenario carries the docUrl it was verified against and the date it was last checked, and 185 of them ship the response example their page publishes, so field names and nesting can be read off rather than guessed at. National clouds covered: commercial, 21Vianet (China), and US Gov.

Lifecycle changes come with their preconditions, not just their endpoints. pc_explain_lifecycle returns the state machine: which operation is legal from which state, the field to read off the live subscription first (cancellationAllowedUntilDate, autoRenewEnabled, suspensionReasons), and the error you get when the precondition fails.

The pack is also browsable as MCP resources (pc://scenarios, pc://errors, pc://auth, pc://reference, pc://sdk-map, pc://enums, pc://deprecations, pc://resources, pc://lifecycle, pc://examples, pc://history, pc://scenario/{id}) and three prompts (migrate-sdk, diagnose-issue, plan-purchase) for hosts that surface them.

Alongside the scenarios it ships enum values, a resource field dictionary, and a deprecations and deadlines timeline. npm run export turns the whole pack into an OpenAPI 3.0 spec and a Postman collection.

Examples

Decode an error you hit in production:

// pc_lookup_error { "code": "900420" }
{
  "httpStatus": 401,
  "errorCode": "900420",
  "description": "The audience in the token is invalid and is no longer supported in Partner Center API.",
  "causes": ["Token requested with the retired graph.windows.net audience"],
  "remediation": "Request the token with resource https://api.partnercenter.microsoft.com ...",
  "docUrl": "https://learn.microsoft.com/partner-center/developer/deprecate-azure-active-directory-graph-token"
}

Lint old auth/client code before you ship it:

// pc_check_auth { "code": "new AuthenticationContext(); get(\"https://graph.windows.net\"); partner.Customers..." }
{
  "findings": [
    { "severity": "error",   "message": "Uses the retired graph.windows.net audience; Partner Center returns 401 / 900420.", "fix": "Request the token with resource https://api.partnercenter.microsoft.com." },
    { "severity": "warning", "message": "Appears to use ADAL, which is deprecated.", "fix": "Use MSAL with the secure application model." }
  ],
  "clean": false
}

Catch a wrong call before you make it:

// pc_validate_request { "method": "POST", "url": "/v1/customers/abc/subscriptions", "headers": { "Authorization": "Bearer x" } }
{
  "ok": false,
  "findings": [
    { "severity": "error", "message": "Path matches a known scenario but the method POST is wrong; expected GET.",
      "fix": "Use GET for /v1/customers/{customer-id}/subscriptions." }
  ]
}

Develop

npm install
npm test
npm run build

The knowledge pack lives in data/ (date-versioned; each record carries a docUrl and lastVerified). Schemas in src/knowledge/schema.ts validate every file at load time, so malformed or drifted data fails fast.

Verification runs in two halves, one offline and one networked.

npm run check-pack is the offline half and runs on every PR. It compares each scenario's method, path, and headers against verification/doc-facts.json, a committed snapshot of what the Learn pages actually say, and lists documented endpoints that still have no scenario.

npm run check-docs is the weekly networked half. It re-fetches every referenced page and diffs it against the snapshot, keying drift off the source commit each Learn page embeds. It fails on a dead, moved, or replaced page, on a page that became unreadable, and when a field the pack depends on changed. The weekly GitHub Action opens an issue when that happens. An upstream edit that touched only prose is reported without failing the run. npm run check-docs:update does the same fetch and rewrites the snapshot; npm run docfacts:refresh rebuilds it from scratch across the whole developer/ section of the Learn table of contents.

For the rest: npm run eval runs a deterministic golden-case suite, npm run eval:llm (needs ANTHROPIC_API_KEY) checks that a real model picks the right tool for a question, and npm run export emits the OpenAPI spec and Postman collection.

npm run read-doc -- <slug> prints one Learn page as plain text, which is how new scenarios get authored. npm run examples:refresh re-collects the response examples; it merges rather than overwrites, so a run that Learn rate-limits cannot lose the previous one's work.

The .NET server in dotnet/ exposes the same 28 tools from the same data/ pack and ships to NuGet as tunahanaliozturk.PartnerCenterMcp. dotnet test PartnerCenterMcp.Tests runs its suite, one test of which asserts the two servers expose the same tool names.

npm run pack-diff reports what changed since the last recorded release, comparing a fingerprint of every scenario's route, auth, headers, fields, response shape and gotchas. Re-verifying a scenario is deliberately not a change. npm run pack-diff -- --record X.Y.Z writes the result into data/history.json, which is what the pc_diff_pack tool serves.

Contributing

New scenarios and doc-accuracy fixes are very welcome. See CONTRIBUTING.md. This is an unofficial, community project and is not affiliated with Microsoft.

Available Tools

29 tools
pc_auth_guidanceGet authentication guidanceA
Read-onlyIdempotent

Return how to authenticate against Partner Center for a given token flavour and national cloud: the token resource and authority to use, the ordered steps of the flow, Secure Application Model and MFA requirements, and what is deprecated. Use this when deciding or setting up how to get a token. To check whether existing code already uses a retired pattern, use pc_check_auth instead; to decode a 401/403 you already hit, use pc_decode_error. Read-only, offline, deterministic. Returns guidance only — it issues no tokens, contacts no identity provider, and handles no secrets.

Inputs: authType (required), cloud. Returns: ok, data, error, suggestions

pc_build_requestBuild a ready-to-send requestA
Read-only

Assemble one Partner Center REST request as structured data: the resolved URL with your params substituted into the path placeholders, concrete headers (Bearer plus a freshly generated MS-RequestId on writes), and a request-body skeleton derived from the operation's documented fields. Use this when you want an object to send from your own client. For a language-specific code snippet use pc_generate_call instead, and to lint a request you already wrote use pc_validate_request. Read-only and offline: the request is constructed and handed back, never sent, and the Authorization header is a <access-token> placeholder — no credentials are read or required. Not idempotent in one respect: a random MS-RequestId is minted on each call for write operations, so reuse the returned value across retries rather than calling again. Unsupplied placeholders are reported in missingParams rather than failing, and an unknown id returns ok:false with suggestions.

Inputs: id (required), params. Returns: ok, data, error, suggestions

pc_check_authLint auth code for retired patternsA
Read-onlyIdempotent

Scan a Partner Center auth or client code snippet for retired and deprecated patterns — the graph.windows.net token audience, ADAL, the archived .NET SDK, and the AzureAD/MSOnline PowerShell modules — and return the severity, explanation, fix, and doc link for each hit. Use this to triage existing code before or after a 401. For guidance on what to build instead, use pc_auth_guidance; to translate archived SDK calls into REST, use pc_migrate_from_sdk. Read-only, offline, deterministic pattern matching: the snippet is not executed, nothing is sent anywhere, and no code is modified. A clean snippet returns findings: [] with clean: true. Detection is regex-based, so a clean result is not a guarantee of correctness.

Inputs: code (required). Returns: ok, data, error

pc_decode_errorDecode a raw error responseA
Read-onlyIdempotent

Take a raw Partner Center error response and decode it: extract the error code, HTTP status, and MS-CorrelationId, then return the documented causes, remediation, likely scenarios, and the exact wording to quote in a support request. This is the right first tool when something failed and you have the response in hand. Use pc_lookup_error instead when you have already isolated a clean code, and pc_diagnose when you only have a prose description with no response body. Read-only, offline, deterministic parsing — the input is never sent anywhere and no request is replayed. Always returns ok:true: an unrecognised code still yields the parsed fields, status-based candidates, and a note on what to try next.

Inputs: error (required). Returns: ok, data, error

pc_diagnoseDiagnose a symptomA
Read-onlyIdempotent

Match a Partner Center problem described in plain language against the documented errors and return the likely candidates plus an ordered fix path. Use this when you have no error body and no code — just a description of what is going wrong. If you have the raw response use pc_decode_error, and if you have a clean code use pc_lookup_error; both are far more precise than this. Read-only, offline, deterministic keyword matching, so the candidate list is a heuristic shortlist and can be empty or noisy. Always returns ok:true; nextSteps is a fixed checklist and is returned even when nothing matched.

Inputs: symptom (required). Returns: ok, data, error

pc_diff_packSee what changed between knowledge pack releasesA
Read-onlyIdempotent

Return the scenarios added, changed, or removed across releases of this pack, newest first. Use it to find out what moved since the version you last built against: a changed scenario means its route, auth, headers, request fields, response shape, or documented constraints are not what they were. This tracks THIS PACK, which follows Microsoft Learn. It is the closest thing here to an API changelog, but it is not Microsoft's. For deprecations and enforcement deadlines use pc_whats_new instead; for one scenario's current detail use pc_get_scenario. Read-only, offline, deterministic.

Inputs: id, since. Returns: ok, data, error

pc_explain_lifecycleExplain the subscription lifecycleA
Read-onlyIdempotent

Return the subscription lifecycle state machine: which operations (increase-seats, decrease-seats, upgrade, cancel, renew-change, suspend, reactivate, migrate, transfer) are legal from which state, the field to read off the live subscription before attempting each one, the scenario that performs it, and the error codes a failed precondition returns. Use this to answer "what can I do to this subscription right now" before reaching for an endpoint. For the endpoint itself use pc_get_scenario, for an ordered call sequence use pc_plan_subscription_change, and to decode a rejection use pc_lookup_error. Read-only, offline, deterministic. Omit operation for the whole machine.

Inputs: operation. Returns: ok, data, error

pc_explain_policyAnswer a question about how Partner Center behavesA
Read-onlyIdempotent

Answer questions about Partner Center's RULES rather than its endpoints: cancellation windows per product type, what happens when a customer does not pay, how promotion limits are counted, what a GDAP expiry does to subscriptions, how billing and proration work. This is the tool for "why was this refused", "how long do we have", "who is liable", "does this carry over at renewal". For the endpoint that performs an operation use pc_get_scenario; for whether an operation is legal right now use pc_explain_lifecycle; for a specific error code use pc_lookup_error. Read-only, offline, deterministic. Every entry carries the Microsoft Learn page it was read from and the date it was checked.

Inputs: area, limit, question. Returns: ok, data, error

pc_generate_callGenerate REST call codeA
Read-onlyIdempotent

Emit ready-to-adapt code for one Partner Center scenario in the language you ask for, plus the Secure Application Model token exchange, 429 retry, 202 polling, and pagination boilerplate. Use this when you want code. For a structured method/url/headers/body object to send yourself, use pc_build_request; for the underlying facts and gotchas, use pc_get_scenario. Only current REST is emitted — never the archived .NET SDK. Read-only, offline, deterministic: the code is returned as text and is never executed, and the placeholder credentials it contains are read from environment variables at your end. An unknown id returns ok:false with suggestions listing every valid id.

Inputs: id (required), language (required), includeHelpers. Returns: ok, data, error, suggestions

pc_get_enumsLook up enum valuesA
Read-onlyIdempotent

Return the accepted values for a Partner Center enum, each with a note on what it means — billingCycle, termDuration, targetView, segment, transitionType, subscriptionStatus, qualification, agreementType, billingType, provisioningStatus and more. Use this before sending a request body so you send a value the API will accept, rather than guessing a plausible-looking string. For the fields of a whole resource use pc_get_resource; for a pre-filled body skeleton use pc_build_request. Read-only, offline, deterministic. Omitting name returns the index of every enum instead of one enum's values. An unknown name returns ok:false with suggestions listing all valid enum names.

Inputs: name. Returns: ok, data, error, suggestions

pc_get_referenceGet API-wide reference factsA
Read-onlyIdempotent

Return the cross-cutting facts that apply to every Partner Center call rather than to one operation: base URLs, required headers, API versioning, the sandbox account, rate limits, and national cloud differences. Use this for questions about the API as a whole. For a specific endpoint use pc_get_scenario, and for authentication specifics use pc_auth_guidance. Read-only, offline, deterministic. topic is required and the payload shape differs per topic.

Inputs: topic (required). Returns: ok, data, error

pc_get_resourceLook up a resource's fieldsA
Read-onlyIdempotent

Return the field dictionary for a Partner Center resource — Customer, Subscription, Order, Invoice, CartLineItem and others — listing each field's name, type, and usage note. Use this to understand a payload you received or to work out what a request body needs. For the accepted values of an individual field use pc_get_enums, and for a ready-to-fill body skeleton for a specific operation use pc_build_request. Read-only, offline, deterministic. Omitting name returns the index of every resource instead of one resource's fields. An unknown name returns ok:false with suggestions listing all valid resource names.

Inputs: name. Returns: ok, data, error, suggestions

pc_get_scenarioGet one scenario in fullA
Read-only

Return the complete verified record for one Partner Center REST operation: method, path, auth type, required headers, request and response shapes, per-field notes, working curl/C#/TypeScript examples, gotchas, and the doc link. Use this once you know the scenario id — get one from pc_list_scenarios, a pc_plan_* workflow, or pc_lookup_error. For runnable code in a specific language prefer pc_generate_call; for a request body skeleton prefer pc_build_request. Read-only. Offline and deterministic unless enrich is set, which adds a live Microsoft Learn fetch. An unknown id returns ok:false with suggestions listing close or valid ids.

Inputs: id (required), enrich. Returns: ok, data, error, suggestions

pc_list_scenariosList available scenariosA
Read-onlyIdempotent

List every Partner Center REST operation this server knows about, as a compact index of id, title, area, method, resolved url, and auth type. Start here to discover what is available and to find the scenario id that the other tools take; then call pc_get_scenario for the full record or pc_generate_call for code. This is a catalogue of documented operations, not a query against a live tenant — it returns no customer data. Read-only, offline, deterministic. Filtering by an area with no entries returns an empty list rather than an error.

Inputs: area. Returns: ok, data, error

pc_lookup_errorLook up an error codeA
Read-onlyIdempotent

Look up a Partner Center error by its numeric code or HTTP status and return what it means, its known causes, the remediation, the doc link, and the scenarios where it usually appears. Use this when you already have a clean code. If you have a raw error response, pc_decode_error is better — it extracts the code and correlation id for you first. For a symptom described in prose with no code at all, use pc_diagnose. Read-only, offline, deterministic. Exactly one of code or httpStatus must be supplied; supplying neither returns ok:false. An unknown code returns ok:false with suggestions listing every code in the pack.

Inputs: code, httpStatus. Returns: ok, data, error, suggestions

pc_migrate_from_sdkMap archived SDK calls to RESTA
Read-onlyIdempotent

Find the archived Partner Center .NET SDK calls in a snippet and map each one to the current REST scenario that replaces it, with migration notes. Use this to port code off the SDK, which was archived in June 2023. Run pc_check_auth alongside it to catch retired auth in the same snippet, then pass each returned scenario id to pc_generate_call to emit the replacement code. Read-only, offline, deterministic pattern matching: the snippet is not executed and nothing is rewritten in place — you get the mapping, not modified code. Always returns ok:true; when nothing matched, matches is empty and unmatched is true.

Inputs: code (required). Returns: ok, data, error

pc_plan_csp_onboardingPlan CSP customer onboardingA
Read-onlyIdempotent

Return the ordered CSP customer onboarding workflow: send the reseller relationship invitation, confirm the customer accepted it, record the Microsoft Customer Agreement, then read their subscriptions. Use this to link an existing tenant to your CSP account before you can transact for them. For admin access on top of the relationship use pc_plan_gdap_onboarding; to move an already-linked customer between partners use pc_plan_transfer. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_plan_gdap_onboardingPlan GDAP onboardingA
Read-onlyIdempotent

Return the ordered GDAP onboarding workflow — create the relationship, lock it for customer approval, poll until active, then bind access assignments. Use this when you need granular delegated admin rights over a customer tenant. Note these steps are Microsoft Graph calls, not Partner Center ones; for the commercial relationship (invitation + agreement) use pc_plan_csp_onboarding, which is the usual prerequisite. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_plan_order_lifecyclePlan an order from cart to provisioned subscriptionsA
Read-onlyIdempotent

Return the ordered workflow that takes a purchase from cart to confirmed, provisioned subscriptions: build the cart, check out, poll the order's provisioning status, resolve the subscriptions it created, and confirm each one provisioned. Use this when a purchase has to be verified rather than assumed. For choosing WHAT to buy use pc_plan_purchase; for changing a subscription afterwards use pc_plan_subscription_change. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_plan_prerequisitesPlan the calls that produce a scenario's parametersA
Read-onlyIdempotent

Given any scenario, return the ordered calls that produce the ids its path needs, plus the parameters you have to supply yourself. Answers "I want to call this, what do I need first" for every operation in the pack, not just the ones with a hand-written workflow. For a business sequence and its preconditions prefer the curated planners: pc_plan_purchase, pc_plan_subscription_change, pc_plan_order_lifecycle, pc_plan_transfer, pc_plan_csp_onboarding, pc_plan_gdap_onboarding, pc_plan_user_onboarding, pc_plan_user_offboarding, pc_plan_reconciliation. This one only resolves parameters, which is why it works everywhere. Planning only: nothing is executed, no credentials are used, no network call is made.

Inputs: id (required), customerId. Returns: ok, data, error

pc_plan_purchasePlan an NCE purchaseA
Read-onlyIdempotent

Return the ordered end-to-end New Commerce purchase workflow — find the product, get a fresh SKU availability, build the cart, check out, resolve the provisioned subscriptions — with the exact operation, resolved URL, and key gotchas for each step. Use this to buy new subscriptions for a customer. To move existing subscriptions between partners use pc_plan_transfer, and to link the customer to your account first use pc_plan_csp_onboarding. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code.

Inputs: country, customerId. Returns: ok, data, error

pc_plan_reconciliationPlan invoice reconciliationA
Read-onlyIdempotent

Return the ordered invoice reconciliation workflow for a billing period: locate the invoice, read its totals, pull billed and unbilled line items, download the statement. Use this for billing and revenue reconciliation. Note the v1 line-item endpoints are being retired in favour of async Graph v2 exports — call pc_whats_new for the cutoff dates before building on them. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_plan_subscription_changePlan a subscription lifecycle changeA
Read-onlyIdempotent

Return the ordered call sequence for one subscription lifecycle change: increase-seats, decrease-seats, upgrade, cancel, renew-change, suspend, reactivate, migrate or transfer. Each plan reads the subscription first, states the precondition that decides whether the change is legal, performs it, and confirms it. Use pc_explain_lifecycle to find out WHICH operation is available; use this to find out HOW to run it. For a new purchase use pc_plan_purchase, and for the order side use pc_plan_order_lifecycle. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: operation (required), customerId. Returns: ok, data, error

pc_plan_transferPlan an NCE transferA
Read-onlyIdempotent

Return the ordered New Commerce transfer (billing-ownership change) workflow: create the transfer, poll it, verify the moved subscriptions. Use this when a customer is moving to a new partner of record. For a first-time customer link-up use pc_plan_csp_onboarding instead, and for buying new subscriptions use pc_plan_purchase. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_plan_user_offboardingPlan user offboardingA
Read-onlyIdempotent

Return the ordered workflow for removing a user from a customer tenant in the safe order: read their licenses, reclaim the seats, strip directory roles, then delete the account. Use this to decommission a person without stranding licenses. The inverse is pc_plan_user_onboarding; cancelling the subscriptions themselves is a different concern. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_plan_user_onboardingPlan user onboardingA
Read-onlyIdempotent

Return the ordered workflow for onboarding a user inside a customer tenant: pick available SKUs, create the account, assign licenses, grant directory roles, verify. Use this for people-level provisioning. It is unrelated to buying subscriptions — for that use pc_plan_purchase — and the reverse direction is pc_plan_user_offboarding. Planning only: nothing is executed, no Partner Center credentials are used, and no network call is made — it is a lookup over the bundled scenario pack. Returns { goal, steps[] with order/scenarioId/method/path/url/authType/why/keyGotchas/docUrl, notes[] }. Pass any step's scenarioId to pc_generate_call for runnable code, or pc_get_scenario for its full record.

Inputs: customerId. Returns: ok, data, error

pc_search_docsSearch live Partner Center docsA
Read-only

Search the live Microsoft Learn Partner Center developer documentation and return matching excerpts. Use this as the fallback when the curated pack has no answer: try pc_list_scenarios / pc_get_scenario / pc_lookup_error first, since those are verified and offline. Reaches the public internet, so results are not deterministic and the call can be slow or come back empty with a note when the fetch fails. Read-only and safe to retry; no Partner Center credentials are involved. Returns { excerpts[] with title/url/text, note }.

Inputs: query (required), topK. Returns: ok, data, error

pc_validate_requestLint a REST requestA
Read-onlyIdempotent

Check a Partner Center REST request you have already written against the documented operations and report what is wrong: unrecognised or mismatched method and path, missing Authorization or MS-RequestId, a retired token audience, app-only used where it is not supported, and sovereign-cloud host mismatches. Use this to catch mistakes before sending, or to explain a call that is failing. To build a correct request from scratch instead, use pc_build_request; to decode a response you already received, use pc_decode_error. Read-only, offline, deterministic: the request is analysed statically and never sent, so pass placeholder tokens rather than real ones. Findings are limited to what the bundled pack covers, so an empty list means no known problem — not a guarantee the call will succeed.

Inputs: url (required), method (required), cloud, headers, +1 more. Returns: ok, data, error

pc_whats_newList deprecations and deadlinesA
Read-onlyIdempotent

List the Partner Center API deprecations and retirement deadlines — MFA enforcement, the graph.windows.net retirement, DAP to GDAP, v1 to v2 reconciliation, and the SDK/ADAL/AzureAD retirements — each with its date, impact, and the action to take, newest deadline first. Use this before committing to an endpoint or auth mechanism, and to explain why something that used to work has stopped. To check whether specific code is affected, run pc_check_auth on it. Read-only, offline, deterministic — sourced from the bundled pack, so it is only as current as the pack's last refresh rather than a live feed.

Inputs: status. Returns: ok, data, error

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 29 tools

    Disambiguation4/5

    The pc_* prefix and explicit cross-references keep most tools distinct, and the error-handling trio is cleanly split by input type (raw response vs isolated code vs prose). However, pc_plan_purchase and pc_plan_order_lifecycle overlap in the cart/checkout/subscription-resolution steps, so an agent could plausibly select the wrong planner.

    Naming Consistency4/5

    Nearly all tools follow a pc_<verb>_<noun> pattern, and the shared prefix makes the family easy to recognize. Minor deviations like pc_auth_guidance, pc_whats_new, and pc_diagnose break the otherwise consistent verb-noun convention, so it is not a perfect 5.

    Tool Count2/5

    At 29 tools, this clearly exceeds the 25-tool threshold and feels heavy for an agent to reason about. Several families—especially the ten pc_plan_* tools and the three error/lookup tools—could reasonably be consolidated into parameterized variants without losing functionality.

    Completeness5/5

    The surface covers the full knowledge lifecycle: discover scenarios, inspect details, build or validate requests, generate code, decode errors, plan business workflows, check auth, track deprecations, and explain policies. Cross-references leave no obvious dead ends, and pc_search_docs plus pc_plan_prerequisites fill gaps not covered by curated workflows or the bundled pack.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      A simple demonstration MCP server that provides an echo tool and resource for learning how to build MCP servers. Serves as a starting point and template for creating custom MCP server implementations.
      1
      -
    • A
      license
      B
      quality
      B
      maintenance
      Provides a reference MCP server that implements every MCP feature so client, gateway, and runtime authors can test against a single endpoint, and publishes a service contract describing its capabilities.
      31
      1
      MIT