← Plugin catalog
Business & Operations

Wingspan

Wingspan v1.0.0

Manage your flexible workforce

Create a free account to save this plugin.

From the developer

Not specified in the available declarations: capabilities, limitations, pricing & account requirements.

Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 21, 2026. Package observed Nov 20, 2026.

View package source →

Description

From the marketplace listing

Wingspan is the AI-native platform for the flexible workforce, built for finance and operations teams that manage and pay 1099 contractors, international contractors, and seasonal, temporary, and part-time W-2 employees. It brings onboarding, verification, work, billing, payments, tax compliance, and reporting together on one worker record. This plugin connects your AI assistant to Wingspan through our permissioned MCP server, so you can get Wingspan work done without switching apps. Invite contractors, review onboarding progress, identify missing requirements, and confirm whether a worker is ready to pay. Create payables, retrieve payment amounts, deductions, status, and history, or filter payments and calculate totals using the same criteria available in Wingspan. Human approval stays in control. Plugin requests approval before executing, creates new payables as drafts, and never moves money. Final approval and payment execution remain in Wingspan, with your existing permissions and audit trail preserved. Requires a Wingspan account with payer access.

Language: English · Automatically detected from descriptions.

What changed

Similar plugins

Finding similar plugins… Results will appear here automatically.

Browse plugins →

Files & skills

File archives

Plugin package20 files · 25.1 KBBrowse files →
Skill instructions
checking-payments10.2 KB

View saved version →

---
name: checking-payments
description: Look up what a company owes its contractors through Wingspan and what has happened to a particular payment. Use for "what do we owe", "what did we pay last month", "how much is outstanding", "what is awaiting approval", "show me [name]'s payments", "what happened to this payment", "why has this not been paid yet", "has this been paid", "is this payment disputed".
---

# Checking payments

The shared rules for every call — ids, paging, previewing a write, what the
tools cannot do — are in the `using-wingspan-tools` skill. Apply them here.

A **payable** is one payment owed to one contractor — the row on the Payables
screen in the Wingspan app. A **contractor** is a person or business the company
pays. An **engagement** is the named working arrangement a payment is filed
under.

Two tools cover most of this: `search_payables` lists and filters, `get_payable`
reads one payment in full. Every row a search returns carries a `payableId`, and
that is the id `get_payable` takes. A third, `get_payroll_preview`, reads what
the next payroll run would pay as things stand today.

## Listing and searching

`search_payables` with no arguments lists every payment except cancelled ones,
25 to a page.

| Argument | What it does |
| --- | --- |
| `query` | Free-text search over the contractor's name, email and company, plus the invoice number. At least two characters; a full email address matches exactly. |
| `status` | Which screen view to read: `all`, `draft`, `toApprove`, `scheduled`, `paid`, `cancelled`. |
| `contractor` | One contractor's payments only — their `contractorId`, your external id for them, or their email. |
| `referenceId` | The one payment carrying your own id for it, set when it was created. No two payables share one. |
| `dueDateFrom`, `dueDateTo` | Bound the due date, as `YYYY-MM-DD`, inclusive. |
| `paidDateFrom`, `paidDateTo` | Bound the date paid, as `YYYY-MM-DD`, inclusive. |
| `sortBy` | `dueDate`, `createdAt`, `updatedAt`, `openedAt`, `paidAt`, `amount` or `scheduledPaymentDate`. One field per call. |
| `sortDirection` | `asc` or `desc`. Defaults to `desc`. Refused without `sortBy`. |
| `limit` | Rows per page, 1 to 100. Defaults to 25. |
| `pageToken` | Continue a previous page. Pass the previous result's `pagination.nextPageArgs` back unchanged. |
| `accountId` | Read one child account of an organization instead of the signed-in account. Only when the user names one; `who_am_i` lists them. |

There are no other filters. Do not invent one.

What each `status` view holds:

- `all` — every payment except cancelled ones.
- `draft` — created but not yet opened, so the contractor cannot see it.
- `toApprove` — open and waiting for someone at the company to approve it.
- `scheduled` — approved and waiting for a payroll run.
- `paid` — paid or in transit only. Payments recorded off-platform, partially
  paid or refunded are not in this view; use `all` for a complete history.
- `cancelled` — cancelled. Hidden everywhere else, which is why totals stay
  honest.

Every view, `all` included, also leaves out two kinds of row: the batch-level
total a payroll run creates, which would double-count against the individual
payments, and personal payment-link invoices. Neither can be read by id either.

## Totals

A list normally carries a `summary` with a count and an amount total, covering
**every** payment matching the filters, not only this page. Use it for "how
much do we owe" instead of adding up a page, and say which filters it covers.
When `summary` is null the totals were unavailable — say so rather than summing
the page and presenting it as the total.

A correct total over the wrong set of payments is still the wrong answer, so
pick the view before reading the summary:

- **"What do we owe?"** means approved-and-unpaid plus open-and-unapproved.
  Read `scheduled` (approved, waiting for a payroll run) and `toApprove` (open,
  waiting for approval) separately and report both figures with

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

connect1.81 KB

View saved version →

---
name: connect
description: Check the Wingspan connection and report who it is signed in as. Run this after installing the plugin, after re-authorizing, or whenever the user explicitly wants to confirm ChatGPT is reading the correct Wingspan account.
---

# Check the Wingspan connection

Call `who_am_i`. It takes no arguments and performs a real authenticated read,
so a successful answer proves the whole connection works end to end.

Then report, in plain sentences:

- **Connected as** — the person's email address, when the connection
  identifies an individual. No name is returned. An authorization granted
  through the browser identifies the company account rather than the
  individual, and the person comes back unavailable; say that it identifies the
  account, and do not present it as a problem.
- **Reading as** — the account from `account` when present, otherwise the
  matching entry in `accounts`. `actingAsAccountId` is always null here,
  because `who_am_i` takes no `accountId`; ignore it.
- **Accounts reachable** — the entries in `accounts`, by name, noting any that
  sit under a parent account. Mention that a tool can be pointed at one of them
  with its `accountId` if the user needs a different one. An empty `accounts`
  list is legitimate, not a fault.

Then say what the connection is for in one line: these tools read the
contractors this account pays, what it owes them, and their onboarding
paperwork, and they can create contractor records and draft payments after
showing a preview. Paying, approving and anything requiring an extra identity
challenge stay in the Wingspan app.

## If it fails

Follow the `troubleshooting` skill. In short: an authentication
failure means re-authorizing through `/mcp`; no Wingspan tools at all means the
server is not connected, and that skill says how to tell the two apart.

Referenced files: 1 — file references are metadata, not package contents.

creating-draft-payables10.3 KB

View saved version →

---
name: creating-draft-payables
description: Create draft payables — new payment obligations to contractors — in Wingspan. Nothing is paid. Use for "log a payment", "pay [name] $500 for [work]", "record these payments", "add these payments to the [engagement] engagement", "create payables", "log 12 hours at $85 for [name]", "bill this month's work". Writes to the company's Wingspan account, so it always previews first.
---

# Creating draft payables

The shared rules for every call — ids, paging, previewing a write, what the
tools cannot do — are in the `using-wingspan-tools` skill. Apply them here.

A **payable** is one payment owed to one contractor — the row on the Payables
screen in the Wingspan app. An **engagement** is the named working arrangement
a payment is filed under. A **line item** is one priced line inside a payment.

`create_payables` records payments against contractors' engagements. **It
writes to the company's account, and everything it creates is a draft.**

## Always preview first

1. Call `create_payables` with the rows and no `mode`. It defaults to
   `mode: "preview"`, which writes nothing: it resolves each contractor and
   engagement, checks every amount and date, totals it up, and reports exactly
   what applying would do.
2. Show that preview to the user in full — the per-row amounts, the total, the
   engagement each payment lands on, every warning, and every row that cannot
   be created.
3. Wait for the user to say yes. An earlier "log these payments" is not consent
   to write; the preview is the thing being consented to.
4. Call again with `mode: "apply"`, a `requestId` you have not used before,
   the matching preview's `confirmationToken` unchanged,
   and the **same rows and the same `ref` values** you previewed.

Retrying an apply with the same `requestId` and the same refs returns the
result of the original writes; nothing new is created. That is the only safe way
to retry. A genuinely new attempt gets a new `requestId`.

## Arguments

| Argument | What it does |
| --- | --- |
| `payments` | The rows. At least one, at most 50 per call. |
| `engagement` | An engagement, by name or id, for every row. Omit it and Wingspan uses each contractor's default engagement. A row's own `engagement` overrides it. |
| `dueDate` | Default due date for every row, as `YYYY-MM-DD`. Required unless every row sets its own. |
| `currency` | Currency for every row. Defaults to US dollars. |
| `mode` | `preview` (the default, writes nothing) or `apply`. |
| `confirmationToken` | Required with `apply`; copy it verbatim from the matching preview. If it expires or arguments change, preview again. |
| `requestId` | Required with `apply`. An id of your own, up to 64 printable characters with no spaces. |
| `accountId` | Write into one child account of an organization instead of the signed-in account. Only when the user names one; `who_am_i` lists them. |

Each row in `payments`:

| Field | What it does |
| --- | --- |
| `contractor` | **Required.** Their email, your external id for them, or their contractor id. |
| `ref` | Your label for this row, echoed in the result. Up to 48 printable characters, no spaces and no colon. Defaults to `row-1`, `row-2` and so on. |
| `referenceId` | Your own id for this payable, stored on it and searchable afterwards with `search_payables`' `referenceId` filter. One per payable — two cannot share one. |
| `engagement` | The engagement for this row, by name or id. Overrides the top-level one. |
| `amount` | A flat amount in dollars, for example `1200.50`. |
| `quantity` | Units worked, for example hours. Goes with `unitCost`. |
| `unitCost` | Amount per unit, in dollars. Goes with `quantity`. |
| `unit` | What a unit is: `"Hour"`, `"Unit"`, or a label of your own. Defaults to `"Unit"`. |
| `description` | What the work was. Shown as the line item's title. |
| `detail` | Longer detail underneath the line item. |
| `dueDate` | Due date for this row, as `YYYY-MM-DD`. Overrides the top-le

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

finding-contractors12.7 KB

View saved version →

---
name: finding-contractors
description: Find, filter and inspect the contractors a company pays through Wingspan, including who still has onboarding paperwork outstanding. Use for "who do we pay", "list our contractors", "find [name]", "who has not signed up yet", "who is missing their W-9", "who is blocked by the certificate of insurance", "which contractors are blocked from being paid", "can we pay [name]", "what is [name]'s status", "who is on this engagement".
---

# Finding contractors

The shared rules for every call — ids, paging, previewing a write, what the
tools cannot do — are in the `using-wingspan-tools` skill. Apply them here.

A **contractor** is a person or business the company pays; Wingspan also calls
this a *payee*. An **engagement** is a named working arrangement a contractor
is assigned to. A **requirement** is something a contractor must satisfy before
they can be paid, such as a tax form or an insurance certificate.

Two tools cover this: `search_contractors` lists and filters, and
`get_contractor` reads one contractor in full. Every row a search returns
carries a `contractorId`, and that is the id `get_contractor` takes.

## Listing and searching

`search_contractors` with no arguments lists active contractors, newest first,
25 to a page.

| Argument | What it does |
| --- | --- |
| `query` | Free-text search over name, email, company and your own external id. At least two characters. Results come back by relevance. |
| `status` | Which screen tab to read: `active`, `notSignedUp`, `incomplete`, `complete`, `archived`. |
| `onboarding` | Where the working relationship stands: `Pending`, `Active`, `Inactive`. |
| `eligibility` | `blocked` or `clear`, as reported by the search API. Missing eligibility is neither; use the verification workflow below before concluding nobody is blocked. |
| `engagement` | Only contractors assigned to this engagement, by name or id. |
| `batch` | Only contractors loaded by one bulk import in the Wingspan app, by that import's batch id. |
| `requirement` | Only contractors whose copy of this requirement is in `requirementState`. |
| `requirementState` | Which state that requirement is in. Defaults to `incomplete`. |
| `sortBy` | `createdAt` or `updatedAt`. One field per call. |
| `sortDirection` | `asc` or `desc`. Defaults to `desc`. Refused without `sortBy`. |
| `limit` | Rows per page, 1 to 100. Defaults to 25. |
| `pageToken` | Continue a previous page. Pass the previous result's `pagination.nextPageArgs` back unchanged. |
| `accountId` | Read one child account of an organization instead of the signed-in account. Only when the user names one; `who_am_i` lists them. |

Use the current tool schema for supported filters. Do not invent filters or assume this table is exhaustive.

## Two separate questions, two separate arguments

`status` is the tab strip from the Wingspan app, and it mixes the working
relationship with paperwork: `incomplete` and `complete` are a summary of
requirements, while `notSignedUp` and `archived` are about the relationship.

`onboarding` is the relationship on its own, and every row reports it whatever
you filtered on.

The two combine, so `status: "notSignedUp"` with `onboarding: "Pending"` means
"invited, has not signed up". One pair is refused rather than answered:
`onboarding: "Inactive"` together with `status: "active"`, because `active`
excludes archived contractors and `Inactive` requires them. `status` defaults
to `active`, so leaving it out is the same pair — send `onboarding: "Inactive"`
with `status: "archived"`.

One more thing worth passing on: `onboarding: "Inactive"` matches archived
contractors, but a contractor who only rejected their invite is not matched.
The underlying search cannot express "archived or rejected" in one query, and
the result's `note` says so.

**One kind of contractor no filter finds:** someone archived before any
engagement was assigned to them. Every `status` tab except `active` needs a
paperwork or engagement

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

onboarding-contractors6.9 KB

View saved version →

---
name: onboarding-contractors
description: Add contractors to Wingspan, assign them to an existing engagement and send their invites. Use for "add these contractors", "onboard these people", "invite [name] to Wingspan", "create contractor records", "set up these five contractors", "invite this roster", "add them to the [engagement] engagement". Writes to the company's Wingspan account, so it always previews first.
---

# Onboarding contractors

The shared rules for every call — ids, paging, previewing a write, what the
tools cannot do — are in the `using-wingspan-tools` skill. Apply them here.

A **contractor** is a person or business the company pays; Wingspan also calls
this a *payee*. An **engagement** is a named working arrangement a contractor is
assigned to. An **invite** is the email that lets the contractor claim their own
Wingspan account.

`create_contractors` does three things in one call: it creates each contractor
record, assigns each one to an existing engagement, and emails the invite to
everyone who has not come on board yet. **It writes to the company's account.**

## Always preview first

1. Call `create_contractors` with the rows and no `mode`. It defaults to
   `mode: "preview"`, which writes nothing: it looks up the engagement, checks
   every email address, and reports exactly what applying would do — including
   which rows already exist.
2. Show that preview to the user in full: how many would be created, how many
   would be skipped, which rows have problems, which engagement each one would
   be assigned to, and how many invite emails would be sent and to how many
   people.
3. Wait for the user to say yes. Do not treat an earlier "add these people" as
   consent to write; the preview is the thing being consented to.
4. Call again with `mode: "apply"`, a `requestId` you have not used before,
   the matching preview's `confirmationToken` unchanged,
   and the **same rows and the same `ref` values** you previewed.

## Arguments

| Argument | What it does |
| --- | --- |
| `contractors` | The rows. At least one, at most 50 per call. |
| `engagement` | An existing engagement, by name or id, to assign every row to. A row's own `engagements` overrides it. |
| `sendInvites` | Email the invite to everyone not yet on board. Defaults to true. |
| `mode` | `preview` (the default, writes nothing) or `apply`. |
| `confirmationToken` | Required with `apply`; copy it verbatim from the matching preview. If it expires or arguments change, preview again. |
| `requestId` | Required with `apply`. An id of your own, up to 64 printable characters with no spaces. |
| `accountId` | Write into one child account of an organization instead of the signed-in account. Only when the user names one; `who_am_i` lists them. |

Each row in `contractors`:

| Field | What it does |
| --- | --- |
| `email` | **Required.** The invite goes here, and it identifies the contractor. |
| `ref` | Your label for this row, echoed in the result. Up to 48 printable characters, no spaces and no colon. Defaults to `row-1`, `row-2` and so on. |
| `name` | Full name. Split into first and last name at the first space, exactly as the Wingspan app does. |
| `company` | Business name, if they invoice as a company. |
| `externalId` | Your own id for this contractor, for reconciliation. |
| `phone` | Contact phone number. |
| `engagements` | Engagements for this row specifically, by name or id. Overrides the top-level `engagement`. |

There are no other fields. Do not invent one — custom fields and group
membership are app work.

## What `requestId` and `ref` are for

Every write carries a key built from your `requestId` and the row's `ref`. If an
apply half-succeeds and you call again with the *same* `requestId` and the same
refs, you get back the result of the original writes; nothing new is created.
That is the only safe way to retry. Change the `requestId` only when
starting a genuinely new attempt, and never renumber refs between the preview
and the ap

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

outstanding4.1 KB

View saved version →

---
name: outstanding
description: List the contractors who have one named onboarding requirement outstanding, such as a W-9, a certificate of insurance or a background check. Run it with the requirement's name. It reports who has not finished the requirement; it does not confirm whose payments are blocked by it.
---

# Who still has this outstanding: $ARGUMENTS

A **requirement** is something a contractor must satisfy before the company can
pay them. The company configures each one once, and every contractor placed on
an engagement gets their own copy. This answers "who has not finished
$ARGUMENTS". It does not answer "whose payment is blocked": whether an
outstanding copy blocks payment depends on where it was attached, which these
tools do not read.

If no requirement was named, list the company's requirements with
`search_requirements` and ask which one the user means. Do not guess.

## Step 1 — find the requirement

Call `search_requirements`. Match `$ARGUMENTS` against the `name` of each
result, case-insensitively and in full. A partial name does not count as a
match. The result is one page; if nothing on it matches and the result carries
`pagination.nextPageArgs`, call again with those arguments and keep going until
a match appears or there is no next page. Only then is "no match" true.

- **No match on any page.** Show the names that came back and ask which one
  was meant. Do not substitute a similar-sounding one.
- **More than one match.** Show the candidates and ask. Requirement names can
  be near-identical across engagements, and answering for the wrong one is
  worse than asking.

Keep two fields from the match: its `requirementDefinitionId` and its
`blocking` value.

## Step 2 — find who has not finished it

Call `search_contractors` with `requirement` set to that
`requirementDefinitionId` and `requirementState` set to `incomplete`, which
means outstanding — the contractor has not finished it.

That returns one page. Report the page, then offer the next one using the
result's `pagination.nextPageArgs`; do not fetch further pages unasked.

## Step 3 — report

Lead with the count and the requirement's full name, worded as "have this
outstanding", not "are blocked". Then list the contractors by name, with their
onboarding state, so the user can see who has not even signed up yet versus
who signed up and has not finished.

Always add this caveat, whatever the definition's `blocking` value says:
whether an outstanding copy actually holds up a payment depends on where the
requirement was attached to that contractor. A placement that is not blocking
only tracks the copy; an engagement placement can also block eligibility while
still allowing payment. `get_contractor` does not read that setting and treats
every incomplete requirement as blocking, so the Wingspan app is the place to
confirm before telling anyone their payment is or is not blocked. If the
definition is not marked blocking, say so as well: an outstanding copy is then
usually tracked rather than holding anyone up.

Then add whichever of these applies:
- **If the user wants a different slice**, the same pair of calls answers it
  with a different `requirementState`: `pendingReview` for submitted and not
  yet reviewed, `expiring` for satisfied but about to lapse, `expired` for
  lapsed, `complete` for finished.
- **A rejected or revoked requirement reads as outstanding again.** One the
  company rejected, or one whose underlying record was revoked or failed, is
  reopened rather than failed, with a reason recorded. There is no failed
  state, so say "reopened after review" rather than "never started" about such
  a contractor.

For one contractor's full picture, `get_contractor` with their `contractorId`.

## What cannot be done from here

Nudging a contractor, approving or rejecting what they submitted, resetting or
renewing a requirement, and extending an expiry date all happen in the Wingspan
app. So does everything the contractor does themselves — signin

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

troubleshooting5.31 KB

View saved version →

---
name: troubleshooting
description: Diagnose Wingspan connection and permission problems. Use when a Wingspan tool returns an authentication or permission error, when tools report nothing, when an answer appears to come from the wrong company or account, or when someone asks whether ChatGPT is connected to Wingspan.
---

# Troubleshooting the Wingspan connection

The Wingspan tools read one company's records, over a connection the user
authorized in their browser. When something looks wrong, the question is
almost always which account the tools are reading as, or whether the
authorization is still good.

## Run `who_am_i` first

`who_am_i` takes no arguments and is the only honest check that the connection
works, because it performs a real authenticated read. What it reports:

- The signed-in person's email address, and no name, when the connection
  identifies a person. An authorization granted through the browser identifies
  the company account rather than the individual, and in that case the person is
  reported as unavailable — that is expected, not a fault.
- `actingAsAccountId` — always null from `who_am_i`, because it takes no
  `accountId`; ignore it. The account the answers are about is `account`, which
  the browser authorization names, or the entry in `accounts` matching the
  signed-in person. Other tools read as a child account only when a call passes
  `accountId`.
- `accounts` — the accounts this connection can reach, with names and any
  parent account. An empty list is legitimate, not a fault.

Report what it says before theorising.

## Not authorized, or authorization expired

An authentication failure means the connection needs re-authorizing. Open the
connector or MCP settings, select Wingspan, and complete login in the browser.

Two things worth knowing so you can describe this accurately:

- Access is granted for a short window and then renewed automatically. This
  plugin asks for the permission that makes silent renewal possible, so a
  working connection normally stays working without anyone doing anything.
- If the renewal itself fails — the authorization was revoked, or the browser
  session is long gone — every tool starts failing at once. Re-authorizing
  through `/mcp` is the fix, not retrying the tool.

If a tool reports that the token was rejected, the message carries a request id
when Wingspan supplied one. Give that id to the user; it is the handle Wingspan
support needs to find the failure.

## The answers are for the wrong company

Two causes, and `who_am_i` distinguishes them.

**The connection is bound to a different account than the user expected.**
`account` names the account the authorization covers when the report carries
one; otherwise it is the entry in `accounts` matching the signed-in person.
`accounts` shows what else is reachable. A person who works with more than one
Wingspan account has to authorize the one they mean.

**The company is an organization with child accounts.** Nine of the ten
tools take an optional `accountId` that acts as one child account instead of the
default; `who_am_i` takes no arguments at all. Use `accountId` only when the user
names a specific child account, and take the id from `who_am_i`'s `accounts`
list. Do not guess an id, and do not sweep across children unasked.

## The answers are empty

Before concluding there is no data:

- `search_contractors` defaults to active contractors and excludes archived
  ones. A name search that finds nothing reports how many archived contractors
  do match; offer to look there.
- `search_payables` excludes cancelled payments unless asked for them.
- A contractor with no engagement assignment has no paperwork summary at all,
  so the tabs that filter on paperwork will not return them.
- These tools answer only for the company doing the paying. If the user wants
  to know what someone owes *them*, these tools cannot answer it, and their own
  Wingspan account is where to look.

The `finding-contractors` and `checki

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

using-wingspan-tools8.97 KB

View saved version →

---
name: using-wingspan-tools
description: >-
  The shared rules every Wingspan tool call follows: ids, paging, previewing a write, and what the tools cannot do. Load this before any Wingspan tool call, and whenever someone asks about the people they pay through Wingspan, what they owe, onboarding paperwork, invites, invoices or payments — for example "who do we pay", "what do we owe this month", "is this contractor ready to be paid", "add these contractors", "log a payment", "why has this not been paid".
---

# Using the Wingspan tools

Wingspan is a payments platform. A company that pays people uses it to bring
those people on board, collect their tax and compliance paperwork, and pay
them. This plugin gives ChatGPT read access to that company's own records, plus
three carefully limited write actions.

## Words used throughout

- **Payer** — the company doing the paying. Everything here is written from
  the payer's side.
- **Contractor** (called a *payee* inside Wingspan) — a person or business the
  payer pays.
- **Engagement** — a named working arrangement a contractor is assigned to,
  such as "Q3 copywriting" or "Design retainer". Payments are filed under an
  engagement, and requirements can be attached to one.
- **Requirement** — something a contractor must satisfy before the payer can
  pay them: a tax form, a signature, an insurance certificate, a background
  check. A requirement the payer configured is a *definition*; one contractor's
  copy of it is an *instance*.
- **Payable** — one payment owed to one contractor. In the Wingspan app this is
  a row on the Payables screen.

These tools answer only for the company doing the paying. If you want to know
what someone owes you, they cannot answer it.

For unfamiliar terminology, read [references/glossary.md](references/glossary.md).

## The ten tools

| Tool | What it answers | Reads or writes |
| --- | --- | --- |
| `who_am_i` | Does the connection work, and which account is it reading? | Reads |
| `search_contractors` | Who do we pay? Who matches this name? Who is held up? | Reads |
| `get_contractor` | Can we pay this one contractor, and if not, why? | Reads |
| `search_requirements` | What must a contractor satisfy before we can pay them? | Reads |
| `search_payables` | What do we owe, and what have we paid? | Reads |
| `get_payable` | What happened to this one payment? | Reads |
| `get_payroll_preview` | What would the next payroll run pay, as things stand today? | Reads |
| `create_contractors` | Create contractors, assign an engagement, send invites. | **Writes** |
| `create_payables` | Log payments as drafts. | **Writes** |
| `open_payables` | Release drafts so contractors can see them. | **Writes** |

In a tool list these appear as `mcp__codex_apps__wingspan_mcp2_who_am_i` and so
on. Reason about the short names above.

Use the available Wingspan-MCP2 tool schemas for exact arguments; tool prefixes can vary by host. If a schema differs from a field list below, follow the current schema.

## Rules for every call

**Use the id the search gave you.** Each row from `search_contractors` carries
a `contractorId`, and each row from `search_payables` carries a `payableId`.
Those are the ids `get_contractor` and `get_payable` accept. Ids copied from
anywhere else — a spreadsheet, a URL, another system — will usually be
rejected.

**One page per call.** `search_contractors` and `search_payables` return a
single page, then hand back `pagination.nextPageArgs`: the complete set of
arguments for the next call. Show the page to the user and offer to fetch the
next one. Do not loop through pages unasked. A page token only works with the
exact same filters and sort that produced it, so pass `nextPageArgs` back
unchanged.

**Read the `note`.** Every list result carries a plain-sentence `note` saying
how many rows came back, how the list was sorted, and what to do next. It also
warns about things that are easy to misread, such as a filter that cannot
return what the user expe

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package author
Wingspan

Package observed Nov 20, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 21, 2026 · 00:00 UTC
Collection status
Collected

plugin_asdk_app_6aa7b09b97808191b0ced38534cd8782

Download plugin data (JSON)

Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.