# io.github.tunahanaliozturk/partner-center-mcp (npm · partner-center-mcp) Unofficial Partner Center REST API knowledge & codegen assistant (scenarios, auth, errors). - Trust score: 81/100 (high trust) - Change this week: +51 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-08-03 ## Components - npm · `partner-center-mcp`: 81/100 (this document), [markdown](https://verifymcp.io/servers/tunahanaliozturk-partner-center-mcp/partner-center-mcp.md), [page](https://verifymcp.io/servers/tunahanaliozturk-partner-center-mcp/partner-center-mcp) ## Channel facts - Registry: `npm` - Package: `partner-center-mcp` - Version: `0.13.0` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-08-03. - **Supply Chain Security**: 86/100 - No malware found by supply-chain analysis. - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree. - No install/post-install scripts declared. - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree. - **Provenance & Transparency**: 97/100 - Source repository is publicly reachable at the declared URL. - Cryptographically verified build provenance (signed, bound to tunahanaliozturk/partner-center-mcp). - Clear OSI-approved license (MIT). - Actively maintained (last published 2 days ago). - Disclosure check failed: no security disclosure policy was found in the source repository. - **Schema Quality & AI Usability**: 88/100 - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name). - AI-judged instruction clarity (excellent). - Tool/resource definitions use about 8914 tokens (~51/item across 172 items; 26 tools + 146 resources), lean. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 23/100 - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (100% of tools); any adoption earns full credit. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### Claude ```bash claude mcp add tunahanaliozturk-partner-center-mcp -- npx -y partner-center-mcp ``` ### Codex ```bash codex mcp add tunahanaliozturk-partner-center-mcp -- npx -y partner-center-mcp ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "tunahanaliozturk-partner-center-mcp": { "type": "local", "command": [ "npx", "-y", "partner-center-mcp" ], "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add tunahanaliozturk-partner-center-mcp --command npx --arg -y --arg partner-center-mcp ``` ### Hermes ```yaml mcp_servers: tunahanaliozturk-partner-center-mcp: command: "npx" args: ["-y", "partner-center-mcp"] ``` ### Other ```json { "mcpServers": { "tunahanaliozturk-partner-center-mcp": { "command": "npx", "args": [ "-y", "partner-center-mcp" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-08-02 (score 81, +55) - [security improvement] Install scripts: unverified → pass - [security improvement] Known CVEs: unverified → partial - [security improvement] Provenance: unverified → pass - [security improvement] Malware scan: unverified → pass - [security] The attested source repository moved: tunahanaliozturk/partner-center-mcp - [functional improvement] MCP protocol: unverified → pass - [functional improvement] Maintenance: unverified → pass - [functional improvement] Stability: unverified → 0.20 - [functional improvement] Dependency health: unverified → partial - [functional improvement] License: unverified → pass - [functional improvement] Schema quality: unverified → excellent - [functional] Licence: MIT ### 2026-08-01 (score 26, +21) - [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet. - [functional regression] Schema quality: 21 → 51 - [functional regression] Schema quality: fair → unverified - [functional improvement] Tool coverage: 0% → 100% - [functional improvement] Schema quality: unverified → 100 - [functional improvement] Tool coverage: unverified → 100 - [functional] First check of Tool coverage: 100 - [functional] Capabilities: Protocol version not yet verified: we do not have a sandbox capture of the MCP handshake this version of the package performs yet. - [functional] Package version: 0.12.0 → 0.13.0 ### 2026-07-31 (score 5, −1) - [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server ### 2026-07-30 (score 6, −61) - [security regression] Provenance: pass → unverified - [security regression] Install scripts: pass → unverified - [security regression] Known CVEs: partial → unverified - [security] The attested source repository moved: tunahanaliozturk/partner-center-mcp - [functional regression] Maintenance: pass → unverified - [functional regression] Dependency health: partial → unverified - [functional regression] Schema quality: 100 → unverified - [functional regression] Tool coverage: 100 → unverified - [functional regression] License: pass → unverified - [functional] Licence: MIT - [functional] Package version: 0.11.0 → 0.12.0 ### 2026-07-28 (score 67, +37) - [security improvement] Install scripts: unverified → pass - [security improvement] Known CVEs: unverified → partial - [security improvement] Provenance: unverified → pass - [security] The attested source repository moved: tunahanaliozturk/partner-center-mcp - [functional improvement] Maintenance: unverified → pass - [functional improvement] Dependency health: unverified → partial - [functional improvement] Schema quality: unverified → fair - [functional improvement] License: unverified → pass - [functional] Licence: MIT ### 2026-07-27 (score 30) First indexed and scored. ## MCP tools (26) ### `pc_list_scenarios` (~182 tokens) List available scenarios 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. Input parameters: - `area` (string): Restrict the list to one functional area. One of: customers, subscriptions, orders, licenses, invoicing, profiles, auth, catalog, utilities, audit, support, security, analytics, devices, referrals. O… Output parameters: - `data` (array): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_get_scenario` (~267 tokens) Get one scenario in full 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. Input parameters: - `enrich` (boolean): Set true to also fetch live Microsoft Learn excerpts for this operation and attach them as `liveDocs`. Defaults to false. Turning it on adds a network round-trip and makes the result non-deterministi… - `id` (string, required): Exact scenario id in kebab-case, e.g. "create-cart", "get-invoices", "list-customer-subscriptions". Case-sensitive; call pc_list_scenarios to discover valid ids. A near miss comes back as `suggestion… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_search_docs` (~221 tokens) Search live Partner Center docs 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 }. Input parameters: - `query` (string, required): What to look up, in plain language or as keywords — e.g. "cart line item promotion eligibility" or "MS-CorrelationId header". "Partner Center" is prepended automatically, so do not repeat it. An erro… - `topK` (integer): Maximum number of excerpts to return, 1-10. Omit to get everything the fetcher found (usually a handful). Lower it to keep the response small. Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_auth_guidance` (~240 tokens) Get authentication guidance 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. Input parameters: - `authType` (string, required): Which token flavour to describe. "app+user" is the Secure Application Model refresh-token flow required by most Partner Center operations; "app-only" is application permissions, which only a subset o… - `cloud` (string): Sovereign cloud whose endpoints and authority to return. Defaults to "commercial". Choose "china-21vianet" or "us-gov" only for tenants in those clouds — their authorities and feature availability di… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_check_auth` (~234 tokens) Lint auth code for retired patterns 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. Input parameters: - `code` (string, required): The code to lint, pasted as-is. Any language — C#, TypeScript, PowerShell, or a raw token request URL. A partial snippet is fine: only the auth-related lines matter, and matching is case-insensitive.… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_generate_call` (~301 tokens) Generate REST call code 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. Input parameters: - `id` (string, required): Exact scenario id in kebab-case, e.g. "create-cart". Case-sensitive; discover ids with pc_list_scenarios or any pc_plan_* tool. - `includeHelpers` (boolean): Whether to append the reusable boilerplate — token exchange, 429/Retry-After handling, 202 polling, pagination — as a separate `helpers` field. Defaults to true. Set false when you already have that… - `language` (string, required): Target language for the snippet. Required — there is no default. "curl", "csharp", and "typescript" come from curated per-scenario examples; "powershell" is generated from the endpoint definition and… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_migrate_from_sdk` (~203 tokens) Map archived SDK calls to REST 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. Input parameters: - `code` (string, required): C# code that calls the archived SDK, pasted as-is — e.g. a block using IAggregatePartner or PartnerService.Instance. A fragment is enough; matching is on the SDK call chain and is case-insensitive. M… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_lookup_error` (~264 tokens) Look up an error code 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. Input parameters: - `code` (string): Partner Center error code as a string, e.g. "900400" or "20002". Matched exactly, so strip surrounding text first. Takes precedence when both this and `httpStatus` are given. Supply this or `httpStat… - `httpStatus` (integer): HTTP status code to list errors for, e.g. 400 or 403. Use this when you have no Partner Center code — it returns every documented error with that status, so expect several. Ignored when `code` is sup… Output parameters: - `data`: The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_diagnose` (~208 tokens) Diagnose a symptom 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. Input parameters: - `symptom` (string, required): What is going wrong, in plain language — e.g. "checkout returns 400 for NCE carts in Germany" or "token works for Graph but Partner Center says unauthorized". Matching is keyword-based and case-insen… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_get_reference` (~186 tokens) Get API-wide reference facts 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. Input parameters: - `topic` (string, required): Which reference topic to return. "base-urls": host per API surface. "headers": the headers every request should carry and why. "versioning": how API versions are selected. "sandbox": integration sand… Output parameters: - `data`: The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_validate_request` (~421 tokens) Lint a REST request 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. Input parameters: - `authType` (string): The token flavour you intend to use. Supply it to be told when the endpoint does not accept app-only. Omit to skip that check. - `cloud` (string): Sovereign cloud the request targets. Defaults to "commercial". Supply a non-commercial value to get the correct base URL and login authority reported as an info finding. - `headers` (object): Request headers as a flat string-to-string map, e.g. { "Authorization": "Bearer ", "MS-RequestId": "..." }. Names are compared case-insensitively. Omit to skip the header checks entirely — whi… - `method` (string, required): HTTP verb of the request you are checking. Required — a verb that does not match the endpoint is one of the things this reports. - `url` (string, required): The request URL. A full URL or a bare path both work; the scheme and host are stripped before matching. Concrete ids in place of {placeholder} segments are expected and matched positionally, e.g. "ht… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_purchase` (~322 tokens) Plan an NCE purchase 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. Input parameters: - `country` (string): Optional two-letter ISO 3166-1 country code for the customer's market, e.g. "TR", "DE", "US". Substituted for the {country} placeholder in the catalog steps, since product availability and pricing ar… - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). Substituted for the {customer-id} placeholder in every step's path and url so the plan comes back ready… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_get_enums` (~203 tokens) Look up enum values 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. Input parameters: - `name` (string): Enum to expand, e.g. "billingCycle" or "subscriptionStatus". Matched case-insensitively. Omit it to list every available enum with its description and value count, then call again with the one you wa… Output parameters: - `data`: The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_whats_new` (~195 tokens) List deprecations and deadlines 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. Input parameters: - `status` (string): Filter by lifecycle stage. "upcoming": announced, deadline not reached. "in-progress": rolling out now. "enforced": deadline passed and being applied. "retired": fully removed. Omit to get every item. Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_get_resource` (~190 tokens) Look up a resource's fields 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. Input parameters: - `name` (string): Resource to expand, e.g. "Subscription" or "CartLineItem". Matched case-insensitively. Omit it to list every documented resource with its description and field count, then call again with the one you… Output parameters: - `data`: The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_explain_lifecycle` (~194 tokens) Explain the subscription lifecycle 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. Input parameters: - `operation` (string): Narrow the answer to one operation: increase-seats, decrease-seats, upgrade, cancel, renew-change, suspend, reactivate, migrate, or transfer. Omit to get every operation. Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_build_request` (~343 tokens) Build a ready-to-send request 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 `` 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`. Input parameters: - `id` (string, required): Exact scenario id in kebab-case, e.g. "create-cart". Case-sensitive; discover ids with pc_list_scenarios or any pc_plan_* tool. - `params` (object): Values for the {placeholder} segments in the operation's path, as a flat string-to-string map — e.g. { "customer-id": "c7f6e4b1-...", "subscription-id": "..." }. Keys are matched loosely, so "custome… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. - `suggestions` (array): Valid values to retry with, returned alongside `error` when the requested identifier was not found. ### `pc_decode_error` (~227 tokens) Decode a raw error response 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. Input parameters: - `error` (string, required): The error response pasted verbatim — a JSON body such as {"code":"900400","description":"..."}, or unstructured log text containing the failure. Include the response headers if you have them so the M… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_transfer` (~264 tokens) Plan an NCE transfer 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_gdap_onboarding` (~279 tokens) Plan GDAP onboarding 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_reconciliation` (~272 tokens) Plan invoice reconciliation 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_csp_onboarding` (~279 tokens) Plan CSP customer onboarding 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_user_onboarding` (~263 tokens) Plan user onboarding 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_user_offboarding` (~264 tokens) Plan user offboarding 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_subscription_change` (~373 tokens) Plan a subscription lifecycle change 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… - `operation` (string, required): Which lifecycle change to plan. One of: increase-seats, decrease-seats, upgrade, cancel, renew-change, suspend, reactivate, migrate, transfer. Required — there is no default. Use pc_explain_lifecycle… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ### `pc_plan_order_lifecycle` (~278 tokens) Plan an order from cart to provisioned subscriptions 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. Input parameters: - `customerId` (string): Optional Partner Center customer tenant id (GUID, e.g. "c7f6e4b1-3a2d-4c5e-9f80-1b2c3d4e5f60"). When supplied it is substituted for the {customer-id} placeholder in every step's path and url, so the… Output parameters: - `data` (object): The result payload. Present only when `ok` is true. - `error` (string): Human-readable reason the call failed. Present only when `ok` is false. - `ok` (boolean): True when the call succeeded and `data` is populated; false when `error` explains why not. ## Diagnostics Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/tunahanaliozturk-partner-center-mcp/partner-center-mcp#diagnostics ## Score history - 2026-08-03: 81 - 2026-08-02: 81 - 2026-08-01: 26 - 2026-07-31: 5 - 2026-07-30: 6 - 2026-07-28: 67 - 2026-07-27: 30 ## Links - npm package: https://www.npmjs.com/package/partner-center-mcp - Socket report: https://socket.dev/npm/package/partner-center-mcp - Repository: https://github.com/tunahanaliozturk/partner-center-mcp - Changelog RSS feed: https://verifymcp.io/servers/tunahanaliozturk-partner-center-mcp/partner-center-mcp/changelog.xml - Changelog JSON feed: https://verifymcp.io/servers/tunahanaliozturk-partner-center-mcp/partner-center-mcp/changelog.json - HTML version of this page: https://verifymcp.io/servers/tunahanaliozturk-partner-center-mcp/partner-center-mcp