Skip to content
KiweelyKiweelyKiweely

Build vs. Buy a Workday MCP Server: OAuth 2.1, SOAP, WQL, and Twice-Yearly Releases

Wrapping GET /workers in a weekend script takes hours, but a company-wide Workday MCP server requires remote OAuth 2.1 brokering, Workday PKCE token sealing, WQL schema discovery, SOAP XML pagination, RaaS parsing, browser write checks, and twice-yearly release updates.

  • By Kiweely
  • 7 min read
On this page

Any competent backend engineer can wire Anthropic’s or OpenAI’s Model Context Protocol (MCP) SDK to Workday’s GET /common/v1/workers endpoint with a static Sandbox token in a single afternoon. Shipping a production company-wide Workday MCP server—safe for every employee across Claude, ChatGPT, and Gemini on web, desktop, and mobile—is a completely different engineering project spanning remote MCP OAuth 2.1 brokering, Workday PKCE token rotation, dynamic WQL schema discovery, SOAP XML snapshot pagination, RaaS prompt marshaling, out-of-band write approvals, and twice-yearly Workday R1/R2 release upkeep.

Before assigning two platform engineers and an HRIS architect to build an internal Workday MCP server, review the seven subsystems your team will actually write, security-review, and carry on pager rotation.

Prototype vs. Production: The Real Engineering Scope

Subsystem Afternoon Prototype (1 Dev) Company-Wide Production Requirement
SubsystemTransport & rollout Afternoon Prototype (1 Dev)Local stdio script on one MacBook Company-Wide Production RequirementPublic HTTPS remote MCP server supporting Claude, ChatGPT, and Gemini across web, desktop, iOS, and Android
SubsystemAuthentication Afternoon Prototype (1 Dev)Hardcoded ISU_* refresh token in .env Company-Wide Production RequirementFull MCP OAuth 2.1 Authorization Server bridging to Workday Register API Client (Authorization Code + PKCE) per employee
SubsystemToken storage & rotation Afternoon Prototype (1 Dev)Plaintext JSON file or Redis cache Company-Wide Production RequirementCryptographic client-sealed grants (AES-256-GCM) + atomic handling of Workday’s rotating refresh_token and non-sliding expiry
SubsystemWorkday data surfaces Afternoon Prototype (1 Dev)3–5 hardcoded REST GET endpoints Company-Wide Production RequirementREST + dynamic WQL (/dataSources discovery, GET/POST /data switching) + SOAP XML (Bearer auth) + Custom RaaS
SubsystemPagination & limits Afternoon Prototype (1 Dev)First 20 rows only Company-Wide Production RequirementWQL 30-minute session cache (limit/offset up to 10k) + SOAP Response_Filter (As_Of_Entry_DateTime & As_Of_Effective_Date)
SubsystemPII & write safety Afternoon Prototype (1 Dev)Raw JSON dumped to LLM and stdout logs Company-Wide Production RequirementSchema-locked zero-body logging, RAM field redaction, and out-of-band browser approval (Now vs. After) for writes
SubsystemOngoing maintenance Afternoon Prototype (1 Dev)None until demo ends Company-Wide Production RequirementWeekly Sandbox refresh URL routing + twice-yearly Workday R1/R2 WSDL, WQL alias, and security regression testing

1. Bridging MCP OAuth 2.1 to Workday’s PKCE Quirks

Remote MCP clients (Claude Enterprise/Team, ChatGPT Enterprise/Team, Gemini) authenticate against remote tool servers using the MCP OAuth 2.1 specification (including Protected Resource Metadata, Dynamic Client Registration or pre-registered workspace credentials, and S256 PKCE). Workday’s OAuth 2.0 server (/{tenant}/authorize and /ccx/oauth2/{tenant}/token) does not implement MCP OAuth 2.1 metadata discovery natively, and exhibits three Workday-specific behaviors your OAuth broker must handle:

  1. Custom Basic header formatting on confidential/PKCE exchanges: Workday’s token endpoint documentation specifies Authorization: Basic ID <Base64> or form-encoded client_id + code_verifier depending on how the client was registered in Register API Client vs. the Developer Site Console (see PKCE OAuth setup with corporate SSO).
  2. Rotating refresh tokens with a fixed wall-clock horizon: Every grant_type=refresh_token POST returns both a new access_token and a new refresh_token. Concurrent tool calls from an LLM (which routinely fires 4 parallel MCP tools/call requests in one turn) will race on refresh rotation unless you implement per-user single-flight locking—and because Workday’s Refresh Token Timeout (in days) never slides forward on refresh, your server must cleanly trigger a fresh OAuth challenge when the original authorization horizon expires.
  3. Eliminating the token database honeypot: If your internal server stores 5,000 employee refresh tokens—including your CHRO’s and CFO’s—in Postgres or Redis, your MCP service immediately becomes a Tier-0 HR credential vault requiring encryption key rotation, SOC/SOX audit controls, and intrusion monitoring.

2. REST Covers Less Than You Think: WQL, SOAP, and RaaS

Teams that start against the Workday REST API Explorer hit coverage walls within week one (detailed in when to use RaaS, WQL, or REST):

  • Live WQL (/wql/v1/data) is required for analytical questions, aggregations, and custom object joins. Because every Workday tenant has thousands of tenanted calculated fields (cf_*) with tenant-specific aliases, an LLM cannot guess WQL syntax from pre-training—it will hallucinate field names and trigger 400 errors. Your MCP server must dynamically query GET /wql/v1/dataSources and GET /wql/v1/dataSources/{ID}/fields, switch automatically from GET /data?query=... (capped at 2,048 characters) to POST /data (up to 16,000 characters), and manage WQL’s 30-minute user-session pagination cache (see paginating WQL past 500 rows).
  • Workday SOAP Web Services (urn:com.workday/bsvc) still own huge swaths of Benefits, Compensation, Payroll, Financial Management, and Recruiting. Calling SOAP on behalf of an SSO employee requires HTTP Authorization: Bearer headers, stripping WS-Security headers, parsing HTTP 500 <SOAP-ENV:Fault> envelopes, and pinning both As_Of_Effective_Date and As_Of_Entry_DateTime inside <bsvc:Response_Filter>—otherwise page 2 defaults to now() in the user’s or server’s timezone and duplicates or drops worker rows:
xml
<bsvc:Response_Filter>
  <bsvc:As_Of_Effective_Date>2026-11-15</bsvc:As_Of_Effective_Date>
  <bsvc:As_Of_Entry_DateTime>2026-11-15T19:30:00Z</bsvc:As_Of_Entry_DateTime>
  <bsvc:Page>2</bsvc:Page>
  <bsvc:Count>100</bsvc:Count>
</bsvc:Response_Filter>
  • Custom Reports-as-a-Service (RaaS) hold the exact definitions your HRIS and Finance teams already trust (urn:com.workday.report/...). Your MCP server has to parse required report prompts, handle backslash owner-name edge cases, and normalize deeply nested wd:Report_Entry JSON/XML structures without blowing out the LLM’s context window.

3. Field Redaction, Zero-Body Observability, and Prompt-Injection Write Defense

Standard APM and logging middleware (pino, winston, OpenTelemetry HTTP auto-instrumentation, API gateway access logs) log query strings, tool arguments, or exception bodies by default. On Workday traffic, one uncaught JSON parse exception dumps worker names, SSNs, or base pay straight into Datadog or CloudWatch. You must write a schema-locked telemetry layer that strips all bodies before serialization.

If management asks to enable even a single write action—such as Request Time Off or updating contact details—relying on the LLM’s system prompt (“Always ask the user before calling submit_time_off”) fails basic application security review. Indirect prompt injection inside an email or resume read in the same chat session can instruct the model to invoke the write tool directly. Preventing that requires building an out-of-band state machine: holding a pending action hash, serving a separate browser confirmation UI showing Now vs. After values fetched from Workday, authenticating the human click, and resuming the transaction.

4. Twice-Yearly Workday Releases (R1 & R2) and Sandbox Refreshes

Building v1.0 is only the down payment. Every Workday customer receives:

  • Weekly service updates and weekly Sandbox refreshes: Every weekend, Sandbox is overwritten by Production, wiping Sandbox-only API Client tests unless you build multi-tenant configuration management across Implementation, Sandbox, Sandbox Preview, and Production.
  • Twice-yearly Feature Releases (March R1 and September R2): Workday delivers preview changes to Sandbox Preview five weeks before Production cutover, retires end-of-life WWS SOAP versions (Request service version has reached its end of life), alters WQL data source filters, and introduces new Business Process validation rules (see our Workday release preparation audit checklist). Your internal engineers now own semi-annual Workday regression cycles forever.

The Math: In-House Build Cost vs. Kiweely Bridge

Even a conservative engineering estimate makes the TCO gap stark:

  • Initial build (6–10 weeks across 1 senior backend engineer + 0.5 InfoSec/HRIS architect): ~$45,000–$80,000 in loaded engineering time before a single employee uses it.
  • Ongoing maintenance (cloud hosting, OAuth/TLS on-call, new RaaS/WQL requests, R1 & R2 release testing — ~15% FTE/year): ~$25,000–$35,000 every year.

Compare that with Kiweely Bridge (coming next; see Bridge compare and Bridge security):

  1. All seven subsystems built, tested, and maintained for Workday: Remote MCP across Claude, ChatGPT, and Gemini on Mac, Windows, web, and phone; Register API Client + PKCE user-delegated OAuth (never an ISU); out-of-the-box REST, live WQL discovery, SOAP reads, and custom RaaS; plus an AI admin agent that sets up Functional Areas in Sandbox, applies RAM field redaction, and tests real roles (Employee, Manager, HR Partner).
  2. Zero stored payloads + out-of-band browser write cards: Employee Workday tokens are sealed with AES-256-GCM inside the MCP client token (zero token database), responses stream through RAM with schema-locked body-free telemetry, and enabled writes pause for a browser card showing Now vs. After.
  3. Need VPC control? Self-host the container without writing the code: If your reason for building in-house is keeping Workday traffic 100% inside your own cloud perimeter, Kiweely Bridge ships as a signed, stateless self-hosted container for AWS ECS, Google Cloud Run, Azure Container Apps, or Kubernetes (alongside Kiweely Cloud and Dedicated single-tenant static IP for Workday Maintain IP Ranges).
  4. Flat company pricing from $499/mo ($5,988/yr):
    • Up to 1,000 Workday employees: $499 / month
    • 1,001 to 5,000 employees: $1,499 / month
    • 5,001 to 20,000 employees: $3,999 / month
    • Over 20,000 employees or Dedicated / Self-Hosted container: Enterprise by quote
    • One person on their own Workday developer tenant: Free (no trial, no card)
    • Every plan includes unlimited calls, Production + all Sandbox and implementation tenants, and automatic twice-yearly Workday release updates.

(And if your engineering backlog also has tickets to build custom employee portals, manager views, or mobile/Teams approval screens on top of Workday APIs, Kiweely Leaf—also coming next—lets HRIS admins describe and publish stateless pass-through Workday UIs in plain English without an Extend license or an internal frontend build. For consultants and developers building inside Workday Extend and Studio right now, Kiweely Vine is live today.)

Frequently asked questions

Why can't we just ship a local stdio Python or Node MCP script to employees?

Local stdio MCP servers (.mcpb bundles or CLI scripts) only run on desktop laptops where Python or Node is installed and managed via MDM—they cannot run on Claude, ChatGPT, or Gemini in web browsers, on iPhones, or on Android devices. Worse, shipping client secrets onto employee laptops breaks OAuth confidentiality, and pushing emergency patches when Workday updates schemas requires an MDM rollout across thousands of machines.

Why isn't wrapping Workday's REST API enough for an internal MCP server?

Workday's REST API covers a narrow slice of self-service and staffing objects. Analytical rollups require WQL (/wql/v1/data), business-specific calculated fields live inside custom Reports-as-a-Service (RaaS), and broad sections of Benefits, Payroll, Financials, and Recruiting are only reachable via Workday Public Web Services (SOAP XML).

What breaks on an in-house Workday MCP server during March (R1) and September (R2) releases?

Twice a year, Workday retires older SOAP WWS versions, changes WQL field and data source aliases, updates required Business Process prompts, and refreshes Sandbox Preview five weeks ahead of Production. An internal engineering team has to regression-test every tool against Sandbox Preview twice a year or face broken employee tools on release weekend.

Can we self-host Kiweely Bridge inside our own cloud VPC instead of building from scratch?

Yes. Kiweely Bridge (coming next) offers a signed, stateless self-hosted container deployment for AWS ECS, Google Cloud Run, Azure Container Apps, or Kubernetes alongside Kiweely Cloud ($499–$3,999/mo by employee count) and Dedicated static-IP hosting—giving your security team zero external network hop without writing or maintaining the Workday protocol stack.

Your Workday work, done by AI.

Kiweely Vine is the AI agent that builds, deploys and tests Extend apps as real people, makes changes in any Workday task screen, answers from your real tenant and builds reports.

Get the next one in your inbox.

One email a month for Workday teams: what’s changing in Workday and what to retest, one tip tried in a real tenant, and what’s new at Kiweely.

We’ll email you once to confirm. Unsubscribe in one click from any issue.