Documentation
Guides and concepts for buyers, suppliers, and the API in between. For the full endpoint-by-endpoint spec, see the API Reference.
Companies, regions and people
Every workspace in Pleaxy belongs to exactly one company. Your email domain isn't part of the tree: Pleaxy uses it only as a hint when someone signs up.
- Company - the organization on Pleaxy. Nothing sits above it: there's no group or parent company. Its administrators are the administrators of any of its buyer or supplier profiles.
- Region - a workspace inside one company, for example EMEA. A region never moves to another company.
- Buyer and supplier profiles - a region's two sides; it has one or both. Each has its own users and roles, purchase orders, invoices, and connections with buyers or suppliers.
Who ends up in which company
- The first person at a work domain founds a new company and becomes its administrator.
- A colleague who signs up later sees, once they've confirmed their email, the companies on Pleaxy that already have people at their domain, each with its regions. They can ask one of those companies' administrators for an invite into a region, or confirm that theirs is a different company and set up a separate one. Separate companies can't see each other's orders, invoices or suppliers.
- An administrator who adds a region adds it to their own company.
- Companies can't be merged. If a separate company was set up by mistake, invite its people into your company's regions instead.
Quickstart
Sign in, connect a cloud provider, and create your first purchase order. The console and the SDKs call the same /v1 API, which you can also call with a scoped API key (see AI agents for minting one). Some actions always need a person signed in to Pleaxy, never an API key: approving, changing approval flows or autonomy, and recording a payment.
import { Pleaxy } from "@pleaxy/sdk";
// The base URL is the origin only: the SDK adds /v1/workspaces/<Workspace ID>.
const pleaxy = new Pleaxy({
baseUrl: "https://api.pleaxy.ai",
apiKey: process.env.PLEAXY_API_KEY, // "<keyId>.<secret>"
workspaceId: process.env.PLEAXY_WORKSPACE_ID, // Company profile → Workspace ID
});
// AWS: start the connection, run the returned setup script in your own
// account, then pass back the read-only IAM role it created.
const setup = await pleaxy.cloudConnections.initAwsCloudConnection();
await pleaxy.cloudConnections.createCloudConnection({
provider: "aws",
accountLabel: "Production payer",
awsConnectionId: setup.connectionId,
roleArn: "arn:aws:iam::912345678901:role/PleaxyBillingRead",
});
const po = await pleaxy.purchaseOrders.createPurchaseOrder({
supplier: "Amazon Web Services",
provider: "aws",
lineItems: [
{
scopeType: "sku",
scopeId: "AWS-EC2-M5LG",
name: "EC2 m5.large",
ruleType: "quantity",
unit: "hr",
unitPrice: 0.096,
qty: 5_000,
nteAmount: 0,
paymentTerms: "Net 30",
validFrom: "2026-01-01",
validUntil: "2026-12-31",
},
],
});
// po.status is "pending_approval" while your approval flow runs, then
// "awaiting_fulfillment". Autonomy, if on, can approve it straight away.Available in your language
Every SDK is generated from the same OpenAPI spec that powers the API Reference, so they stay in lockstep with the API - pick the six we maintain directly, or generate a client for anything else.
Purchase orders & line items
A PO is built from one or more line items, each independently priced and tracked:
- SKU lines - a specific item from a supplier's catalog, billed by quantity × unit price. When the supplier publishes a catalog in Pleaxy, the item id on the line is validated on the server.
- Service or account blanket lines - a not-to-exceed cap covering a whole service or an entire cloud account.
- Custom lines - for anything not on a supplier's catalog, either quantity-based or a flat not-to-exceed amount.
Every line is in the region currency, carries its own payment terms and validity period, and tracks a live balance - consumed vs. remaining - against that period, flagging lines on pace to exhaust early.
Cloud connections
Pleaxy connects read-only to Amazon Web Services (AWS), Google Cloud, Microsoft Azure and Oracle Cloud Infrastructure (OCI) billing, through access you create in your own account with a setup script, and you can revoke it anytime. Pleaxy keeps every purchase order as its own record and doesn't write purchase orders into any cloud provider:
- Amazon Web Services (AWS) - a cross-account IAM role Pleaxy assumes. It reads your issued invoices and Cost Explorer. To have AWS print a Pleaxy PO number on its invoices, add it under Purchase orders in the AWS Billing and Cost Management console.
- Google Cloud - Workload Identity Federation to a service account that can only read your BigQuery billing export. Google has no invoice API, so Pleaxy matches each line of an invoice you upload to the export's cost by service, SKU and project, and uses the month total when a line can't be matched.
- Microsoft Azure - a federated credential on an app in your own tenant. On a Microsoft Customer Agreement it reads your billing profile's invoices and month-to-date cost; on an Enterprise Agreement, with the read-only EnrollmentReader role, the enrollment's monthly balance and month-to-date cost. Pleaxy doesn't attach PO numbers to EA invoices.
- Oracle Cloud Infrastructure (OCI) - an API signing key Pleaxy generates; you upload only the public key. It reads usage invoices where your account has them, and otherwise each closed month's cost.
AI spend
AI spend is what the AI services on your connected cloud billing cost: Amazon Bedrock, SageMaker, Vertex AI, Azure OpenAI, OCI Generative AI and the marketplace models on the same invoice. Pleaxy shows it by invoicer, vendor, model and meter (input, output and cached tokens, provisioned hours), month to date and forecast for the period, against the last closed month, and beside each invoicer the open purchase order lines raised to it and what is left on them - so you know that Bedrock will cost more than PO-8842 has left before the invoice does. Every amount is in the invoicer's billing currency, never converted or summed across currencies.
- The supplier is whoever invoices. The company whose model was used is the
vendoron the line. Claude on Bedrock is AWS spend with vendoranthropic, never Anthropic spend, so grouping by invoicer matches your invoices and grouping by vendor answers what you spend on Claude wherever it is billed. Nothing is counted twice. - Where it comes from - the AI service lines on your connected AWS, Google Cloud, Azure and OCI billing, read through the same read-only access as the rest of the bill and under the same data-source choice: a connection that allows
current_costgives the month to date and a forecast, one that allowsinvoicesthe closed month. AWS gives its AI lines through Cost Explorer only, so an AWS account needscurrent_costfor them, and then shows the closed month too. Nothing new is asked of your account, and a usage type Pleaxy doesn't know yet is kept with its raw name, never dropped. - Rate cards - Pleaxy keeps the public list prices of every vendor and invoicer it maps, with effective dates: a price change is a new entry, so a line is judged against the price that applied on its day. A contract's negotiated rate or discount off list overrides them; the rate cards themselves can't be edited.
In the API, AI spend is a buyer-only resource: GetAiSpend for the figures by invoicer, vendor, model or cost center, ListAiUsageLines for the lines behind them, ListAiRateCards for the price in force on a day, and CheckAiSpend for whether the forecast fits the open purchase order lines and the budget. The MCP server exposes the same as get_ai_spend and check_ai_spend (see AI agents).
Beyond your cloud billing, AI spend covers the AI providers you pay directly, the AI lines on your orders and invoices, cost centers and limits at the provider:
- Direct AI providers - OpenAI and Anthropic connect with a read-only admin key you create in their console and can revoke; Mistral too, where your organization has its Admin API (an Enterprise feature). OpenRouter connects with a management key, CoreWeave with an API token with the Billing Viewer role and Databricks with a service principal; for Snowflake, Pleaxy generates a key pair and you assign its public key to a service user. GitHub connects with an organization owner's personal access token and the organization's name: Pleaxy reads Copilot's billing usage and records each month's active seats for the seat check. The key is checked with one read before it is saved, stored encrypted and never used to change anything at the provider. Each provider's lines are read daily and show as their own invoicer (ListAiProviders, CreateAiProvider).
- AI invoices matched line by line - an AI line on an order, a contract term or an invoice names its model and meter, and each invoice line is held to the order line and contract term for that model: its rate against the contract and the month's list price, its quantity against the usage the provider reported, and what it draws on a commitment. Lines are never matched by description. SuggestAiPoLines prefills an order's AI lines from last month's usage, and ListAiCommitments shows what each commitment has used.
- Cost centers and budgets - attribution rules map providers' tags, labels, projects and workspaces to cost centers (GetAiAttribution). Each budget then counts the month's attributed AI usage as accruing, and Pleaxy alerts when the forecast reaches 80% or 100% of it (ListAiCostCenters).
- Limits at the provider - opt-in. An approved order line can set the provider's own monthly ceiling: an AWS budget, an OpenAI project limit, an Anthropic workspace limit where Anthropic offers it on your account, a Google Cloud budget or spend cap, or an Azure budget, which only alerts. It takes a separate credential you create, never the read-only connection's (SetAiSpendLimit).
- Seat-based AI - per-seat invoices for ChatGPT Enterprise, Claude Enterprise, Microsoft 365 Copilot, GitHub Copilot and Cursor are checked against the active users recorded for the month (SetAiSeatCount). Pleaxy doesn't read your identity provider: a person, a script or an agent records the count.
Approvals & autonomy
Each region has one approval flow for purchase orders and one for invoice payments, which you edit under Workflows in Pleaxy. A new region starts with a single step routed to a region administrator. You build a flow from three kinds of step:
- Approver - one person signs off.
- Parallel approvers - several different people each sign off, in any order.
- Conditional approver - runs only when all of its conditions match. Conditions can check the amount (in the region's currency), the supplier or the requester.
Every step names one specific person, and only that person can act on it. Mark a step Only above the high-value threshold and amounts at or below the threshold skip it. A flow needs at least one step with no conditions, so every order and invoice reaches a person. If you raised the document yourself, your step goes to another administrator. You can approve it yourself only when nobody else in the region could, and it is then marked Self-approved.
On the Autonomous plan you can turn on autonomy, also under Workflows. Pleaxy then approves a purchase order or invoice up to your auto-approve amount by itself, as Pleaxy Autonomy, with the same audit trail. It never does so when a conditional or high-value step applies, or when a purchase order goes over its requester's spend limit. For invoices it's stricter: only an invoice matched against an issued AWS invoice can be auto-approved, and never one a buyer entered or one in another currency. Automation rules let you treat one supplier differently: always send its documents to a person or, on the Autonomous plan, auto-approve them up to an amount.
An API key can read approval flows and autonomy settings, but only a person signed in to Pleaxy can change them, and an API key never approves a step.
const flow = await pleaxy.approvalChains.get("purchase_order"); // or "invoice_payment"
const autonomy = await pleaxy.settlement.getAutonomy();
// { enabled, maxAutoApproveAmount, approvalThreshold }
// approvalThreshold is the high-value threshold. Change these in Pleaxy, under Workflows.Invoice matching
An invoice billed against a purchase order, for a cloud provider you have a live billing connection to, starts in pending match status. Running the match compares the invoiced amount with the usage the provider reported:
- Within 3% →
matched, and it goes to your invoice approval flow. - More than 3% off, or in a different currency →
discrepancy. Pleaxy doesn't convert currencies. Someone checks it against the provider's bill, then resolves it into the approval flow or rejects it. If autonomy is on and the difference is within your auto-approve amount, Pleaxy approves it itself instead, within the invoice limits described under Approvals & autonomy.
An invoice with no purchase order, or no billing connection to check it against, is unverified. A person signed in to Pleaxy reviews it, then sends it to the approval flow or rejects it.
Contracts
A contract records what you agreed with a supplier: its term (a start and an end date), a spend cap with a tolerance, and priced terms such as the rate for an item. Create one in the app, or upload the contract's PDF: Pleaxy reads it into a draft, shows each value with the page and the words it came from, and you review the draft before saving it. Purchase order lines can then be priced from the contract.
Every invoice from that supplier is checked against the contract in force on the invoice's date:
- Dates. The contract is active, and the invoice's date falls within its term.
- Spend cap. The supplier's invoices dated within the term, before tax, stay within the cap plus its tolerance. Only invoices in the cap's currency count. Pleaxy doesn't convert currencies, so an invoice in another currency is marked as not checked against the cap.
- Item rates. A line billed on a purchase order line that was priced from the contract isn't above the contract's rate for that item.
An invoice that breaks one of these is held back, with a finding that says why. Percentage and fixed discounts, credits, tiered pricing, minimum commitments and payment milestones are checked and held the same way; a milestone is billed once, within its amount and, where the contract asks, only after you confirm it was delivered. A price increase past the contract's yearly cap, or past the change in its index (US CPI-U, euro area HICP or UK CPI, from the monthly values your workspace enters), is flagged on the contract as a warning, and Pleaxy reminds you 30 and 7 days before the last day to give notice of renewal or termination, and on that day. Index-linked increases without the index value they need, and clauses whose figures Pleaxy couldn't read, are marked Not checked yet.
A supplier on Pleaxy is asked to acknowledge the contract's terms, and can dispute them with a reason. Its invoices are checked against the terms either way, unless you turn on Require supplier acceptance: the contract then applies only once the supplier accepts it. Amending a contract creates a new version, and each invoice is checked against the version in force on its date. Contracts are managed in the app; they aren't in the public API yet.
Credit and debit notes
A credit note lowers what the buyer owes: returned goods, a price correction, a refund. The supplier issues it against the invoice it corrects, or against the buyer alone, and a buyer can record one the supplier sent outside Pleaxy. A credit note that corrects an invoice and isn't for more than it is accepted at once; any other waits for the buyer to accept or reject it. Accepting a credit for returned goods or a price correction gives its amount before tax back to the purchase order line, so that balance can be used again.
Who settles credits is a workspace setting:
- Pleaxy settles them. Accepted credits are applied to unpaid invoices and lower their amount to pay, and a credit note against an unpaid invoice is applied to it when accepted. Credits can cover an invoice in full: once approved, it's settled by credit with nothing left to pay. Rejecting an invoice gives its applied credits back.
- Your accounting system settles them. Nothing is netted in Pleaxy, and each accepted credit note goes out once in the payment export, as a negative row.
A debit note bills more on an invoice already sent, such as a charge that was left off. It names the invoice it amends and takes its purchase order, PO line and currency, then goes through matching, approval, payment and export like any invoice. It can't amend a rejected invoice or another debit note.
Both are under Invoices in the app, linked to the invoice they amend, and AWS and Azure credit memos arrive as credit notes on their own. In the API they're the invoices resource with a documentType of credit_note or debit_note (see CreateInvoice), and an invoice feed sends them as UBL credit notes and debit notes, cXML credit and debit memos, or JSON with documentType.
Payments
Pleaxy doesn't pay invoices. Once an invoice's approval flow completes, the buyer pays it in its own payment run (approved invoices can be exported for it) and records the payment in Pleaxy. Recording moves no money. The supplier sees the payment as recorded by the buyer and gets a remittance advice. Recording a payment needs a person signed in to Pleaxy, never an API key.
With the payment, or any time after, the buyer can send the supplier a remittance: proof of payment, such as the bank's transfer receipt (PDF, PNG or JPEG, up to 10 MB), and a note of up to 1,000 characters. The supplier is notified, in its Slack or Teams channel too if it routes payment notifications there, and finds the remittance on the invoice. Like recording a payment, sending one needs a person signed in to Pleaxy (see SendRemittance). Export for payment also works on a single invoice.
Document sync
Document sync is for an ERP, billing or cash-application system that follows Pleaxy without anyone retyping. Ask ListSyncEvents what changed since your last call, then read the document each event names: a purchase order as a cXML OrderRequest or a UBL Order, where an invoice stands, an invoice as a UBL Invoice, and each payment with its remittance. An event names a document, never its content, so you always read the current version. Events are kept 30 days and delivered at least once, so the same change can arrive twice.
Every document is the supplier's copy, whoever asks: never the buyer's internal notes, its approvals or who recorded a payment. A buyer's ERP or bank feed records payments with RecordPayments. A supplier's system confirms orders and sends ship notices through the API or as cXML (see Order fulfillment); neither changes the order, and a shipment is never a receipt.
Webhooks
A webhook pushes those same events to your HTTPS endpoint as they happen, so you don't have to poll. An administrator signed in to Pleaxy adds an endpoint, up to 5 per workspace side, and chooses its event types; an API key can't. The endpoint's signing secret is shown once. Each event is POSTed as JSON with the path of the call that reads its document, never the document itself.
Every request carries a Pleaxy-Signature header, t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<body>">, made with the endpoint's secret. Refuse a request whose signature doesn't match or that is more than 5 minutes old:
import { createHmac, timingSafeEqual } from "node:crypto";
// rawBody is the request body exactly as it arrived, before any JSON parsing.
export function isFromPleaxy(signature: string, rawBody: string, secret: string): boolean {
const parts = Object.fromEntries(signature.split(",").map((part) => part.split("=")));
const sentAt = Number(parts.t);
if (!sentAt || Math.abs(Date.now() / 1000 - sentAt) > 300) return false; // more than 5 minutes old
const expected = createHmac("sha256", secret).update(`${parts.t}.${rawBody}`).digest();
const given = Buffer.from(parts.v1 ?? "", "hex");
return given.length === expected.length && timingSafeEqual(given, expected);
}Answer with a 2xx within 10 seconds. Anything else is retried after 1 minute, 5 minutes, 30 minutes, 2 hours, 6 hours, 12 hours and 24 hours, then given up. An endpoint is an https:// address on a host name; deliveries never reach a private network and never follow a redirect. The endpoints and their delivery log are in the Webhooks reference.
AI agents (MCP)
Connecting an agent as yourself, without an API key: Connect an AI agent.
The Pleaxy MCP server exposes purchase orders and invoices as tools for Claude or any other MCP-compatible agent. It's a thin wrapper: every tool call is one authenticated request to the same /v1 API the console and SDKs use, so an agent can do exactly what its API key allows - nothing more.
- Mint a scoped API key with
POST /v1/workspaces/:regionId/api-keyswhile signed in as yourself - an existing API key can't mint another (see API keys). The key takes your own role in the workspace, buyer or supplier, and only an administrator can mint one. A buyer key is read-only unless you give it aprocurementRole, such asrequisitionsto create purchase orders. The response contains the key (shown only once). Then copy the workspace's Workspace ID from Company profile in the Pleaxy console - you need both below. - Check it runs (Node.js 22.18 or later). The server is on npm as
pleaxy-mcp, so there is nothing to build or clone:npxfetches it.shellnpx -y pleaxy-mcp --version - Add it to your MCP client. For Claude Desktop or Claude Code, add this to your MCP config. The base URL is the origin only - the server adds
/v1itself.mcp config · json{ "mcpServers": { "pleaxy": { "command": "npx", "args": ["-y", "pleaxy-mcp"], "env": { "PLEAXY_API_BASE_URL": "https://api.pleaxy.ai", "PLEAXY_API_KEY": "<keyId>.<secret>", "PLEAXY_WORKSPACE_ID": "<Company profile → Workspace ID>" } } } }
One server process serves one workspace - one API key, one Workspace ID. Buyer and supplier keys see the same tool list, but a call outside the key's role (a supplier key calling create_purchase_order, say) is rejected by the API exactly as it would be over REST.
| Tool | Role | What it does |
|---|---|---|
| Workspace and account | ||
| get_buyer_workspace | Buyer | Buyer overview: purchase orders, invoices and which stages the workspace uses |
| get_supplier_workspace | Supplier | Supplier overview: orders received, invoices issued and what is waiting on you |
| list_workspaces | Both | The workspaces the agent may use, with their Workspace IDs |
| whoami | Both | Whose account the server acts as: a signed-in person or an API key |
| Catalogs and purchase orders | ||
| list_catalog_suppliers | Buyer | Connected suppliers whose catalog is open to you |
| list_supplier_catalog | Buyer | Searches one supplier's catalog, at your contracted rate where you have one |
| list_purchase_orders | Both | One page of purchase orders, newest first, with what each line allows and how much has been invoiced against it |
| get_purchase_order | Both | One purchase order: its lines, what was invoiced and received, and how it is matched |
| create_purchase_order | Buyer | Creates a PO from line items; signed in, it acts at once, as you |
| approve_purchase_order | Buyer | Approves a PO at its current step, for the approver it names; signed in, it acts at once, as you. Refused for an API key |
| reject_purchase_order | Buyer | Sends a PO back to whoever raised it, for the approver its step names. Refused for an API key |
| flip_purchase_order_to_invoice | Supplier | Invoices a whole purchase order in one step |
| Purchase requests and budgets | ||
| list_purchase_requests | Buyer | Purchase requests you can see, newest first |
| list_request_types | Buyer | The workspace's request types and their questions |
| get_request_type | Buyer | One request type and its questions |
| get_purchase_request | Buyer | One purchase request: what was asked for, its approvals, budget check and order |
| create_purchase_request | Buyer | Raises a purchase request; it commits nothing until approved and ordered |
| submit_purchase_request | Buyer | Sends your draft purchase request for approval |
| cancel_purchase_request | Buyer | Withdraws a purchase request before it is ordered |
| convert_purchase_request | Buyer | API key only: turns an approved purchase request into a purchase order |
| check_budget | Buyer | Whether an amount fits a cost center's budget, without saving anything |
| get_budget_status | Buyer | Each cost center's budget, committed and spent for the current period |
| Sourcing | ||
| list_sourcing_events | Buyer | Requests for quotes (RFQs), newest first, with answer counts and, once unsealed, the lowest total |
| get_sourcing_event | Buyer | One RFQ: its lines, deadline, invited suppliers and their answers; while open and sealed, only who answered and when |
| get_sourcing_comparison | Buyer | The answers side by side once the RFQ is no longer sealed: prices, lead times, terms, scores and supplier risk |
| create_sourcing_event | Buyer | Drafts an RFQ from an approved purchase request. It never sends anything to suppliers: a person publishes it in Pleaxy |
| Spend | ||
| get_ai_spend | Buyer | AI spend by invoicer, vendor, model and cost center, month to date and forecast |
| list_ai_usage_lines | Buyer | The daily AI usage lines behind that spend |
| list_ai_rate_cards | Buyer | Public AI list prices per invoicer, vendor, model and meter |
| check_ai_spend | Buyer | Whether an invoicer's or cost center's forecast fits its open PO lines and budget |
| list_ai_providers | Buyer | The AI providers connected directly, and when each last synced |
| get_ai_po_lines | Buyer | Suggests PO lines for one invoicer's AI usage in a month |
| get_ai_recommendations | Buyer | AI spend no order covers, and ways to pay less |
| draft_spend_orders | Buyer | Drafts purchase orders for the cloud and AI spend no order covers: one line for a whole cloud account, or a line per model and meter |
| list_ai_commitments | Buyer | Committed AI spend, reserved capacity and prepaid credits, and how much is used |
| get_ai_attribution | Buyer | The rules that assign AI usage to cost centers |
| list_ai_cost_centers | Buyer | Each cost center's AI budget, commitments and forecast |
| list_ai_spend_limits | Buyer | The spending limits Pleaxy set at AI providers, and their state |
| set_ai_spend_limit | Buyer | Sets an approved order line's amount as the provider's monthly limit; signed in, it acts at once, as you |
| list_ai_seat_counts | Buyer | Active users recorded for seat-based AI products |
| record_ai_seat_count | Buyer | Records a seat-based AI product's active users for a month |
| list_focus_exports | Buyer | Whether FOCUS export is on, and the FOCUS exports of the last 7 days |
| create_focus_export | Buyer | Builds a FOCUS file of your invoices, debit notes and accepted credit notes for up to 36 billing months, with download links. It changes nothing in the workspace |
| get_focus_export | Buyer | One FOCUS export of the last 7 days, with fresh download links valid for 15 minutes |
| list_focus_sources | Buyer | Whether FOCUS import is on, and each FOCUS source - an uploaded file or a cloud's own FOCUS export - with its last run |
| get_focus_source_period | Buyer | One stored month of a FOCUS source: totals, each invoice by category and service, and spend by cost center and by issuer |
| list_focus_issuers | Buyer | The invoice issuers in the stored FOCUS months, their billed totals and the supplier each maps to |
| Receipts | ||
| list_receipts | Both | A purchase order's goods receipts and service entry sheets |
| confirm_receipt | Buyer | Records what was delivered on a PO; signed in, it acts at once, as you |
| submit_service_entry_sheet | Supplier | Reports work done on a buyer's purchase order |
| record_receipt_return | Buyer | Records goods sent back to the supplier from a goods receipt |
| approve_service_entry_sheet | Buyer | Approves a supplier's service entry sheet at its current step; signed in, it acts at once, as you. Refused for an API key |
| reject_service_entry_sheet | Buyer | Sends a service entry sheet back with a reason the supplier sees; signed in, it acts at once, as you. Refused for an API key |
| Invoices | ||
| list_invoices | Both | Invoices in the workspace: received by a buyer, issued by a supplier |
| get_invoice | Both | One invoice, with how a credit and rebill stands |
| list_document_comments | Both | The comments on an invoice, purchase order or contract (read only) |
| run_invoice_match | Buyer | Matches an invoice against its order, contract, receipts or cloud usage |
| resolve_invoice_discrepancy | Buyer | Sends a reviewed discrepancy on to approval; signed in, it acts at once, as you |
| approve_invoice | Buyer | Approves an invoice at its current step, for the approver it names; signed in, it acts at once, as you. Refused for an API key |
| reject_invoice | Buyer | Rejects an invoice with a reason the supplier sees; signed in, it acts at once, as you. Refused for an API key |
| link_replaced_invoices | Buyer | Records which invoices a replacement invoice replaces |
| unlink_replaced_invoice | Buyer | Removes a replacement link entered by mistake |
| remind_invoice | Supplier | Nudges whoever is holding up approval, or asks about payment once approved |
| Payments | ||
| list_payments | Both | Invoices by payment state, with totals per currency |
| get_invoice_bank_account | Both | Whether an invoice's payment waits on the supplier's bank details |
| record_payment | Buyer | Records a payment made outside Pleaxy; signed in, it acts at once, as you. Refused for an API key |
| confirm_payment_received | Supplier | Confirms a payment arrived in your bank account; signed in, it acts at once, as you. Refused for an API key |
| report_payment_problem | Supplier | Tells the buyer a payment didn't arrive or the amount differs; signed in, it acts at once, as you. Refused for an API key |
| Supplier risk, credit and questionnaires | ||
| list_bank_accounts_to_approve | Buyer | Supplier bank accounts whose payments wait for an approval |
| list_supplier_risk | Buyer | Each supplier's risk level and why |
| get_supplier_risk | Buyer | One supplier's risk: bank details, screening, questionnaire and documents |
| list_screening_matches | Buyer | Suppliers with a possible or confirmed sanctions match to review |
| get_supplier_screening | Buyer | One supplier's sanctions screening |
| list_credit_requests | Buyer | Requests to suppliers for credit on what they billed above the agreed price |
| get_credit_request | Buyer | One credit request, with credit notes that may answer it |
| draft_credit_request | Buyer | Drafts a credit request to a supplier from a billing audit |
| get_overbilling_recovery | Buyer | What Pleaxy does when an invoice bills above its purchase order or contract: off, watch (only notes what it would hold back) or on (pays what is proven, holds back the rest and asks the supplier for a credit note) |
| list_overbilling_recovery_records | Buyer | The tamper-evident record of what was held back and how each hold ended, newest first, with a check that the chain holds end to end |
| pause_overbilling_recovery | Buyer | Takes overbilling recovery down a step, to watch or off, never up; amounts already held back stay held until their credit requests close |
| get_savings | Buyer | The money Pleaxy saved, per currency and month: stopped before payment, credited back on bills already paid and early-payment discounts taken, by supplier and by check, with the evidence |
| list_questionnaire_templates | Buyer | The supplier questionnaires the workspace keeps |
| get_questionnaire | Buyer | Reads a questionnaire the suppliers you invite answer |
| save_questionnaire | Buyer | Replaces a questionnaire; suppliers already invited keep the version they were sent |