# Approve a milestone, create a payment and attempt processing
Source: https://docs.shorpay.com/api-reference/approve-a-milestone-create-a-payment-and-attempt-processing
/api-reference/openapi.json post /milestones/{id}/approve
# Approve a timesheet and create its scheduled payment
Source: https://docs.shorpay.com/api-reference/approve-a-timesheet-and-create-its-scheduled-payment
/api-reference/openapi.json post /timesheets/{id}/approve
# Get a milestone and its approval version
Source: https://docs.shorpay.com/api-reference/get-a-milestone-and-its-approval-version
/api-reference/openapi.json get /milestones/{id}
# Get a timesheet and its current approval version
Source: https://docs.shorpay.com/api-reference/get-a-timesheet-and-its-current-approval-version
/api-reference/openapi.json get /timesheets/{id}
# Get a workspace contract
Source: https://docs.shorpay.com/api-reference/get-a-workspace-contract
/api-reference/openapi.json get /contracts/{id}
# Get available and pending workspace balances
Source: https://docs.shorpay.com/api-reference/get-available-and-pending-workspace-balances
/api-reference/openapi.json get /balances
# Get current payment state
Source: https://docs.shorpay.com/api-reference/get-current-payment-state
/api-reference/openapi.json get /payments/{id}
# Get the current workspace
Source: https://docs.shorpay.com/api-reference/get-the-current-workspace
/api-reference/openapi.json get /business
# Initialize a draft for review and completion in Shor
Source: https://docs.shorpay.com/api-reference/initialize-a-draft-for-review-and-completion-in-shor
/api-reference/openapi.json post /contracts
# List milestones for a workspace contract
Source: https://docs.shorpay.com/api-reference/list-milestones-for-a-workspace-contract
/api-reference/openapi.json get /contracts/{id}/milestones
# List workspace contracts and optional deletion tombstones
Source: https://docs.shorpay.com/api-reference/list-workspace-contracts-and-optional-deletion-tombstones
/api-reference/openapi.json get /contracts
# List workspace payments for reconciliation
Source: https://docs.shorpay.com/api-reference/list-workspace-payments-for-reconciliation
/api-reference/openapi.json get /payments
# List workspace timesheets
Source: https://docs.shorpay.com/api-reference/list-workspace-timesheets
/api-reference/openapi.json get /timesheets
# Reject a submitted milestone
Source: https://docs.shorpay.com/api-reference/reject-a-submitted-milestone
/api-reference/openapi.json post /milestones/{id}/reject
# Reject a submitted timesheet
Source: https://docs.shorpay.com/api-reference/reject-a-submitted-timesheet
/api-reference/openapi.json post /timesheets/{id}/reject
# Authentication and API keys
Source: https://docs.shorpay.com/developers/authentication
Create, scope, rotate, and revoke credentials for the Shor public API.
The public API is available to enabled employer workspaces. Ask Shor to enable your workspace before connecting an integration. Administrators create credentials in **Settings → API keys**. Copy the secret when it is shown; it cannot be retrieved later. Choose only the scopes the integration needs and an expiry date. Rotate before expiry, update your secret store, then revoke the old credential. Never put keys in browser code or source control.
Use the API base URL supplied for your environment. All resource paths start with `/v1`. Test credentials are accepted only by the matching test environment. The current contract is available without authentication at `/v1/openapi.json`; a [downloadable reference](/api-reference/openapi.json) is included here.
Connecting an AI assistant instead? Start with [Connect AI assistants](/employer/ai-assistants). The [MCP tool reference](/developers/mcp) maps every supported tool to its HTTP route, inputs, scopes, and confirmation requirements.
```bash theme={null}
curl "$SHOR_API_URL/v1/business" \
-H "Authorization: Bearer $SHOR_API_KEY"
```
Keys act as the membership that created them. Leaving the workspace revokes access permanently. A role change applies immediately, including to retries. Admins can manage keys; members can read and create drafts when granted the corresponding scopes; viewers can only read. Timesheet and milestone approvals and rejections require an admin and the corresponding write scope.
| Scope | Operations |
| - | - |
| `read` | Business, contracts, timesheets, milestones, payments and balances |
| `contracts:write` | Initialize a contract draft |
| `timesheets:write` | Approve or reject a submitted timesheet |
| `milestones:write` | Approve or reject a submitted milestone |
## Next steps
* [Public API overview](/developers/public-api)
* [Rate limits](/developers/rate-limits)
* [Errors](/developers/errors)
# API errors
Source: https://docs.shorpay.com/developers/errors
Understand public API error codes and the action to take next.
Errors return `{ error: { type, code, message, status, requestId, details? } }`. Retain the request ID when contacting support; do not log credentials or sensitive request bodies.
| Status/code | Next step |
| - | - |
| 401 `INVALID_CREDENTIAL` | Check credential, expiry and environment |
| 403 `INSUFFICIENT_SCOPE` | Check grant and current membership role |
| 403 `INTEGRATION_DISABLED` / `WRITES_DISABLED` | Contact the workspace administrator or Shor |
| 409 `STALE_RESOURCE_VERSION` | Fetch and review current state before a new intent |
| 409 `IDEMPOTENCY_KEY_REUSED` | Use the original payload or a new intentional operation |
| 409 `OPERATION_IN_PROGRESS` | Retry the same request after a short delay |
| 409 `OPERATION_EXPIRED` | Reconcile resource state; do not blindly repeat the action |
| 409 `EXTERNAL_REFERENCE_EXISTS` | Look up the contract using `externalReference` |
| 429 | Honor `Retry-After` |
| 503 | Retry with backoff; balance is unavailable, not zero |
See [Rate limits](/developers/rate-limits) for request budgets and [Idempotency and retries](/developers/idempotency) before repeating a write.
# Idempotency and retries
Source: https://docs.shorpay.com/developers/idempotency
Retry requests safely and reconcile uncertain outcomes without duplicating actions.
Every POST requires `Content-Type: application/json` and `Idempotency-Key`, a unique intent identifier of 16–128 letters, digits, underscores or hyphens. Generate it once, persist it in your integration, and reuse it with exactly the same request for retries. Generate a new identifier for each intentional new action, even when its arguments are identical.
Successful operation results are retained for seven days. A completed retry returns the original result with `Idempotency-Replayed: true`; current resource state may since have changed. Never reuse an old key after retention. `externalReference` provides durable draft correlation after operation retention and is unique within the workspace and integration principal. Key rotation preserves that principal. An independently created key or a different MCP grant is a different integration.
## Retry policy
Retry transient network/502/503/504 errors with exponential backoff, preserving the key and payload for writes. Resolve validation, authorization and state conflicts before retrying.
A 429 response requires waiting for `Retry-After`. For `STALE_RESOURCE_VERSION`, fetch and review the latest state before creating a new intent. For `OPERATION_EXPIRED`, reconcile the resource before deciding whether to repeat an action. See [API errors](/developers/errors) for the complete recovery table.
The [TypeScript SDK](/developers/polling-and-sdk#typescript-client) documents its automatic retry policy.
# MCP tool reference
Source: https://docs.shorpay.com/developers/mcp
Shows MCP tools, API routes, inputs, permissions, and confirmed-write behavior.
Shor's MCP server exposes 10 read tools and five write tools over the public API. For customer setup, capabilities, and example prompts, start with [Connect AI assistants](/employer/ai-assistants).
## Product MCP and documentation search
The product MCP server at `https://mcp.shorpay.com/mcp` connects to your Shor workspace using OAuth. It can read workspace resources and perform the confirmed actions listed below, subject to your role and granted permissions.
The documentation site also offers a separate MCP server at `https://docs.shorpay.com/mcp` for searching public documentation. That documentation-search server does not provide access to your workspace or authorize product actions. Use the product server when connecting an assistant to Shor.
## Connection and API routes
An assistant sends MCP requests to the hosted **`/mcp` endpoint**, using the server address displayed in **Settings → Integrations**. The HTTP routes below are the underlying public API operations on the API origin; they are not separate MCP endpoints or URLs to enter into the assistant.
Hosted connections use OAuth and are scoped to the signed-in Shor workspace. Setup creates the connection automatically for an admin. API keys are for [direct API integrations](/developers/public-api); do not send an assistant's OAuth token directly to `/v1`.
The [OpenAPI reference](/api-reference/openapi.json) defines HTTP request and response schemas. The API also serves its current contract at `GET /v1/openapi.json` without authentication.
## Read tools
Every tool in this table requires **`read`** and allows the current `admin`, `member`, or `viewer` role within the connection's granted access. Reads do not request write confirmation. Initial hosted setup and connection management require an admin.
| MCP tool | HTTP method and route | Inputs and result |
| - | - | - |
| `get_business` | `GET /v1/business` | No arguments. Returns the current workspace's ID, name, country, business verification status, and timestamps. |
| `list_contracts` | `GET /v1/contracts` | Optional contract filters and pagination. Returns contract summaries. |
| `get_contract` | `GET /v1/contracts/{id}` | Required `id`. Returns a contract summary, including worker ID/name, status, and dates. |
| `list_timesheets` | `GET /v1/timesheets` | Optional timesheet filters and pagination. Returns work periods, units, rates, totals, payment dates, automatic payment settings, and review versions. |
| `get_timesheet` | `GET /v1/timesheets/{id}` | Required `id`. Returns one timesheet, including its `version` and nullable `paymentId`. |
| `list_milestones` | `GET /v1/contracts/{id}/milestones` | Required `contractId`, mapped to the route's `{id}`. Optional status and pagination. Returns milestones for that contract. |
| `get_milestone` | `GET /v1/milestones/{id}` | Required `id`. Returns amount, due/payment dates, status, `version`, and nullable `paymentId`. |
| `list_payments` | `GET /v1/payments` | Optional payment filters and pagination. Returns current payment states, gross/net amounts, and dates. |
| `get_payment` | `GET /v1/payments/{id}` | Required `id`. Returns one payment and its current status. |
| `get_balances` | `GET /v1/balances` | No arguments. Returns available/pending amounts by currency and an `asOf` timestamp. |
IDs are UUIDs returned by Shor. Single resources are objects; lists return `{ data, hasMore, nextCursor }`. Money uses `{ amount, currency }`, with `amount` a decimal string. Dates use `YYYY-MM-DD`; timestamps use UTC ISO 8601. The MCP result carries the JSON representation in a text content block.
### List filters and pagination
All four list tools accept numeric `limit` from **1–100**, defaulting to **25 for MCP**. Direct HTTP list calls default to **50**. Continue with `nextCursor` as `cursor` while `hasMore` is true, keeping the other filters unchanged.
| Tool | Additional filters |
| - | - |
| `list_contracts` | `status`, `updatedSince`, `includeDeleted`, `externalReference` |
| `list_timesheets` | `status`, `contractId`, `updatedSince` |
| `list_milestones` | Required `contractId`; optional `status` |
| `list_payments` | `status`, `contractId`, `updatedSince` |
`includeDeleted` is the string `"true"` or `"false"` (default `"false"`), including in MCP arguments. `updatedSince` is an inclusive UTC timestamp. `externalReference` looks up a draft within the same workspace and integration principal.
Timesheet status filters are `submitted`, `approved`, and `rejected`. Milestone filters are `pending`, `submitted`, `approved`, `completed`, `paid`, and `rejected`. Payment filters are `pending`, `processing`, `completed`, `failed`, and `cancelled`. Contract statuses and complete schemas are in the [OpenAPI reference](/api-reference/openapi.json).
For example, the arguments to `list_timesheets` can be:
```json theme={null}
{ "status": "submitted", "limit": 25 }
```
Milestones have no workspace-wide list or `updatedSince` filter. List contracts first, then scan each relevant contract's milestone pages. For overlap windows, deletion handling, and other reconciliation rules, see [Polling and TypeScript SDK](/developers/polling-and-sdk).
## Write tools
Every write in this table requires **explicit human confirmation** through the MCP host. The scopes listed are required for the MCP tool, and the role is checked against the current membership on every action and replay.
| MCP tool | HTTP method and route | Required MCP scopes | Allowed roles |
| - | - | - | - |
| `create_contract_draft` | `POST /v1/contracts` | `contracts:write` | `admin`, `member` |
| `approve_timesheet` | `POST /v1/timesheets/{id}/approve` | `read` + `timesheets:write` | `admin` |
| `reject_timesheet` | `POST /v1/timesheets/{id}/reject` | `read` + `timesheets:write` | `admin` |
| `approve_milestone` | `POST /v1/milestones/{id}/approve` | `read` + `milestones:write` | `admin` |
| `reject_milestone` | `POST /v1/milestones/{id}/reject` | `read` + `milestones:write` | `admin` |
Approval/rejection tools require `read` because they fetch the resource and its contract before asking for confirmation. Their HTTP POST routes require the corresponding write scope; direct API clients must separately fetch and review the resource to obtain `expectedVersion`.
### Create a contract draft
`create_contract_draft` requires `title` and `intentId`. Optional inputs are `professionalEmail`, `description`, `employmentType`, `contractType`, `countryOfEmployment`, `startDate`, `endDate`, and `externalReference`. Employee contracts require `countryOfEmployment`, and any supplied employment/contract types must agree.
Example tool arguments using a synthetic intent ID:
```json theme={null}
{
"title": "Website redesign",
"externalReference": "example-project-001",
"intentId": "example-draft-001"
}
```
The confirmation displays the workspace and supplied fields. After confirmation, MCP removes `intentId` from the body and sends it as the HTTP `Idempotency-Key` header. The result is a contract summary; direct HTTP creation returns status `201`.
This initializes a draft for completion in Shor. It does not accept the dashboard's nested compensation payload, sign an agreement, or activate a contract.
### Approve or reject submitted work
The four review tools accept `id` and `intentId`. Rejections also require a trimmed, nonempty `reason` of at most 2,000 characters. They act on submitted work; other states may be rejected by the API.
MCP fetches the timesheet or milestone and its contract, then shows the worker, contract, workspace, amount/currency, and payment date for review. Timesheet reviews also include the work period. Approval shows the timesheet's automatic payment setting or the milestone's immediate processing behavior; rejection shows the reason.
The server retains the fetched resource `version` in signed review state. After confirmation, it sends `{ expectedVersion }` for approval or `{ expectedVersion, reason }` for rejection, with `intentId` in `Idempotency-Key`. Do not supply `expectedVersion` or `confirmed` as tool arguments: those fields are not accepted by these tools.
The result is the updated timesheet or milestone. Approval creates a payment; timesheet processing follows its due date and effective automatic payment setting, while milestone approval attempts processing immediately. Follow a returned `paymentId` with `get_payment` to determine payout status. A successful approval is not a completed payout.
## Confirmation, retries, and stale reviews
For the `2026-07-28` protocol, the first write call returns an input-required response containing signed `requestState` and a confirmation request. A compatible host presents that request to the human and resumes with the signed state and accepted input response. Review state lasts **five minutes** and binds the principal, workspace, tool, arguments, and reviewed resource version where applicable.
A model-generated `confirmed` value does not authorize a write. Changing the arguments or reusing another workspace's review fails validation. Remote hosts that cannot carry the required confirmation can read but receive `CONFIRMATION_UNSUPPORTED` for writes. Verify compatibility with the actual host/version; successful tool discovery does not establish support for confirmed writes.
Every intentional write needs a unique `intentId` of **16–128 letters, digits, underscores, or hyphens**. Retain it and the exact arguments across retries of that operation. Successful API results are retained for **seven days**. Do not reuse the ID after retention. For an intentional new action, generate a new ID.
If the review expires or the resource changes, fetch and confirm current details again. A changed resource version returns `STALE_RESOURCE_VERSION`; use a new intent for the newly reviewed action. For an uncertain prior outcome, reconcile the resource/payment state before creating a new operation. An API replay returns the original operation result, which may differ from current resource state.
`externalReference` can correlate contract drafts after operation retention, but is scoped to the workspace and integration principal. Separate MCP grants and independently created API keys are different integrations.
MCP uses the typed client's default 15-second deadline and two retries for network failures and 429/502/503/504 responses. Authorization errors and 409 conflicts need caller handling. See [API errors and retries](/developers/public-api#errors-and-retries) for rate limits and HTTP error semantics.
### Error handling
Tool failures use `isError: true` with a JSON error in text content. API-originated errors include `code`, `status`, and available `requestId`/`retryAfterSeconds`; confirmation failures may contain only `code`. Transport or protocol errors can occur before a tool result is produced.
| Code | Next step |
| - | - |
| `CONFIRMATION_UNSUPPORTED` | Use a host/version that supports the required confirmation, or perform the action in Shor. |
| `CONFIRMATION_DECLINED` | No write was authorized. Stop unless the user requests another review. |
| `CONFIRMATION_MISMATCH` | Arguments or review state no longer match. Start a fresh review. |
| `CONFIRMATION_EXPIRED` | Legacy confirmation timed out. Review again; invalid modern signed state may instead fail at the protocol layer. |
| `STALE_RESOURCE_VERSION` | Fetch and review the latest resource before a new intent. |
| `INVALID_CREDENTIAL` / `INSUFFICIENT_SCOPE` | Check sign-in, workspace, active connection, scopes, and current role. |
| `INTEGRATION_DISABLED` / `WRITES_DISABLED` | Check workspace rollout and write availability with Shor. |
| `IDEMPOTENCY_KEY_REUSED` | Retry only the original arguments, or use a new ID for a separate intended action. |
| `OPERATION_IN_PROGRESS` | Wait and retry the same operation. |
| `OPERATION_EXPIRED` | Reconcile state before deciding whether another action is needed. |
| `EXTERNAL_REFERENCE_EXISTS` | Look up the contract using the same `externalReference`. |
| `TOOL_FAILED` / `MCP_UNAVAILABLE` | Inspect current state before retrying an uncertain write; contact Shor if the failure persists. |
Retain request IDs for support without logging credentials or sensitive request bodies. A failed balance read must not be interpreted as zero.
## Access and discovery
The tool catalog is filtered by effective scopes. For tokens containing signed Shor API scopes, access is the intersection of those scopes, the connection grant, and the current membership role. Hosted sign-in with identity-only scopes creates an admin-scoped grant; subsequent exchanges synchronize its scopes to the current role's allowed API operations. Missing organization, client, or scope claims fail closed. Refresh discovery after changing access; every underlying API call still checks live authorization.
The server also provides these read-scoped MCP features:
| Feature | Identifier | Behavior |
| - | - | - |
| Resource | `shor://business` | Reads the current workspace through `GET /v1/business`. |
| Prompt | `payroll_review` | Supplies a review checklist covering submitted work, amounts, payment dates, automatic payment settings, and explicit approval confirmation. It performs no write itself. |
Protected-resource discovery is available at both `GET /.well-known/oauth-protected-resource` and `GET /.well-known/oauth-protected-resource/mcp` on the MCP origin. The metadata advertises OAuth identity scopes (`openid`, `profile`, `email`, `offline_access`); Shor API permissions are resolved through the connection rather than requested as identity scopes.
## Remote host configuration
Use the hosted server address from Settings for your environment. These examples show the production address; they do not certify a host's support for confirmed writes.
For Claude Code:
```bash theme={null}
claude mcp add --transport http shor https://mcp.shorpay.com/mcp
```
Complete sign-in through the host's OAuth flow. See [Claude Code MCP configuration](https://code.claude.com/docs/en/mcp).
For Cursor, the remote entry in its MCP configuration is:
```json theme={null}
{
"mcpServers": {
"shor": { "url": "https://mcp.shorpay.com/mcp" }
}
}
```
Complete the OAuth prompt after adding it. See [Cursor MCP configuration](https://cursor.com/docs/mcp). For Claude and ChatGPT setup from the dashboard, use [Connect AI assistants](/employer/ai-assistants).
The current tools exclude signing/activation, standalone payout initiation, arbitrary ledger addresses, full worker profiles, general search, upcoming-payment summaries, and webhooks. Use Shor's application for workflows outside this catalog.
# Polling and TypeScript SDK
Source: https://docs.shorpay.com/developers/polling-and-sdk
Reconcile resources and use the typed v1 client.
## Reconcile current state
List endpoints accept `limit` from 1 to 100 (default 50) and an opaque `cursor`. Keep filters unchanged while following a cursor. Cursors are bound to the workspace, resource and filters; never construct or edit them.
Contracts, timesheets and payments support inclusive `updatedSince`. These feeds expose current state, not an event log or a snapshot across pages. Records can move while you scan. Treat polling as at-least-once: deduplicate by resource ID and update timestamp/version, retain an overlap window, and periodically do a full resync. Do not infer deletion from absence on one page or advance your checkpoint to the time the final page arrived. Preserve the start of a scan as your next watermark, with overlap.
Contracts support `includeDeleted=true` so you can reconcile tombstones through `deletedAt`. A deleted worker's embedded name is removed. Timesheets and payments have no public deletion feed. Milestones have no reliable update timestamp: enumerate each contract's milestones again and compare their `version` values. Do not use a created-at cursor as a milestone change feed. Status-filtered lists are useful for queues, but a resource leaving that status will disappear; use unfiltered reconciliation scans for your local replica.
Balance reads are an observation across ledger and database state, with an `asOf` timestamp, not a transactional guarantee or authorization to spend. Available balance deducts unposted outbound commitments and pending withdrawals, floored at zero. The current ledger does not expose pending incoming funds, so `pending` is `0` under the existing wallet semantics. An unavailable or numerically unsafe ledger response returns 503.
## TypeScript client
Use `ShorV1Client` from `@shor/sdk` for the public API. Ask Shor for the package version and installation instructions available to your enabled workspace before using this example. Package distribution is separate from API rollout. The existing `ShorClient` retains its internal application API behavior.
```ts theme={null}
import { ShorV1Client } from '@shor/sdk';
const shor = new ShorV1Client({
baseUrl: process.env.SHOR_API_URL!,
accessToken: process.env.SHOR_API_KEY!,
});
const business = await shor.business.get();
const page = await shor.timesheets.list({ status: 'submitted', limit: 50 });
const reviewed = await shor.timesheets.get(page.data[0].id);
// Obtain the operator's approval for these fetched details first.
const result = await shor.timesheets.approve(
reviewed.id,
{ expectedVersion: reviewed.version },
{ idempotencyKey: crypto.randomUUID() },
);
if (result.paymentId) {
const payment = await shor.payments.get(result.paymentId);
}
```
Namespaces cover `business`, `contracts`, `timesheets`, `milestones`, `payments` and `balances`. Pass an AbortSignal to cancel a request. Defaults are a 15-second total deadline and two retries for network failures and 429/502/503/504 responses. The same payload and intent key are retained across write retries. 409 and authorization errors are not automatically retried. `ShorV1Error` includes the HTTP status, stable code, request ID and Retry-After seconds, without retaining raw provider responses or request secrets.
The public API currently excludes signing/activation, payout initiation, arbitrary ledger addresses, full worker profiles, search, upcoming-payment summaries and webhooks. Use the Shor application for those workflows.
## Generated OpenAPI client
For direct access to generated operation types, use
`createShorV1OpenApiClient({ baseUrl, accessToken })` from `@shor/sdk/openapi` and call
`client.GET('/contracts', { params: { query: { limit: 25 } } })`.
Writes require `params.header['Idempotency-Key']`. This low-level client returns
`{ data, error, response }`, applies bearer authentication, a 15-second timeout
and redirect rejection. It does not retry or runtime-validate response DTOs;
use `ShorV1Client` for those policies. `ShorV1Paths` and `ShorV1Operations` are
generated from the same committed OpenAPI document.
# Public API
Source: https://docs.shorpay.com/developers/public-api
Integrate with your Shor workspace through the versioned API.
The public API is available to enabled employer workspaces. Ask Shor to enable your workspace before connecting an integration. Use the API base URL supplied for your environment; production uses `https://api.shorpay.com`, with resource paths under `/v1`.
Start with [Authentication and API keys](/developers/authentication) to create a credential, choose scopes, and make an authenticated request. That guide also covers expiry, rotation, revocation, membership roles, and test-environment matching.
The current contract is available without authentication at [the production OpenAPI endpoint](https://api.shorpay.com/v1/openapi.json); a [downloadable reference](/api-reference/openapi.json) is included here.
## Integration guides
* [Authentication and API keys](/developers/authentication)
* [Rate limits](/developers/rate-limits)
* [API errors](/developers/errors)
* [Idempotency and retries](/developers/idempotency)
* [Polling and TypeScript SDK](/developers/polling-and-sdk)
* [MCP tool reference](/developers/mcp)
Connecting an AI assistant instead? Start with [Connect AI assistants](/employer/ai-assistants).
Responses contain a curated public representation. Single resources are bare objects; lists return `{ data, hasMore, nextCursor }`. Money is a decimal string with currency precision. Keep it as a string or use a decimal library. Payroll dates use `YYYY-MM-DD`; timestamps use UTC ISO 8601.
## Create a draft
`POST /v1/contracts` initializes a draft for completion and review in Shor. It accepts title, description, professional email, employment/contract type, country of employment, start/end dates and an optional external reference. It does not sign or activate a contract or accept the dashboard's nested compensation/wizard payload.
Every POST requires `Content-Type: application/json` and an `Idempotency-Key`. Follow [Idempotency and retries](/developers/idempotency) to generate and retain one key per intentional action.
```bash theme={null}
curl "$SHOR_API_URL/v1/contracts" \
-H "Authorization: Bearer $SHOR_API_KEY" \
-H "Content-Type: application/json" \
-H "Idempotency-Key: $INTENT_ID" \
-d '{"title":"Design project","externalReference":"your-system-record-123"}'
```
Use `externalReference` to correlate a draft with your integration. Its uniqueness and retention semantics are described in [Idempotency and retries](/developers/idempotency).
## Approve work
Fetch the timesheet or milestone, review its amount, currency and payment date, then send its `version` as `expectedVersion` to `/timesheets/{id}/approve` or `/milestones/{id}/approve`. Rejection uses `/reject` and also requires a nonempty `reason`.
A changed review returns `STALE_RESOURCE_VERSION`. Fetch and review again before creating a new intent. Approval creates a payment; it does not mean the worker has been paid. Timesheet processing follows its due date and effective auto-pay setting. Milestone approval attempts payment processing immediately. Follow `paymentId` and poll the payment resource for pending, processing, completed or failed state.
## Errors and retries
See [API errors](/developers/errors) for response shapes, error codes, and recovery steps; [Rate limits](/developers/rate-limits) for request budgets; and [Idempotency and retries](/developers/idempotency) for safe write retries and reconciliation.
# Rate limits
Source: https://docs.shorpay.com/developers/rate-limits
Request budgets, rate-limit responses, and backoff for the Shor public API.
Limits currently allow 600 reads and 60 writes per principal per minute, with a shared workspace ceiling of 2,000 requests per minute. Failed-auth admission has a separate limit. Responses include rate-limit headers.
A 429 response means the request was rate limited. Honor `Retry-After` before trying again. For writes, retain the same intent key and payload. See [Idempotency and retries](/developers/idempotency) and [API errors](/developers/errors).
# Connect AI assistants
Source: https://docs.shorpay.com/employer/ai-assistants
Use Claude, ChatGPT, or Cursor to review your Shor workspace and confirm supported actions.
Connect Claude, ChatGPT, or Cursor to your Shor workspace to ask questions about contracts, submitted work, payments, and balances. You can also create contract drafts and approve or reject submitted work after reviewing an explicit confirmation request.
The connection uses **MCP (Model Context Protocol)**, a standard that lets AI assistants use tools from another application. Shor supplies the tools and checks workspace access each time they run.
## Connect your assistant
You need an employer workspace with integration access enabled and an **admin** role to set up a connection. Your assistant's plan and workspace policies must also allow custom connections.
In Shor, go to **Settings → Integrations → AI assistants** and choose **Set up** for Claude, ChatGPT, or Cursor.
Follow the setup dialog and copy the server address into your assistant. For Cursor, **Add to Cursor** fills in the address for you. If remote setup is unavailable, contact Shor to check integration availability for your environment.
Complete the hosted sign-in flow, select the intended Shor workspace, and approve access. Adding a server address alone does not grant access. Shor creates the connection automatically; you do not need to create an API key or enter a client ID.
Ask: “Show my Shor workspace and list my contracts.” Check the workspace name before requesting any actions.
For ChatGPT, custom apps are configured under **Settings → Apps** with developer mode enabled where permitted. Select OAuth when configuring Shor. Exact availability and menus depend on your account and workspace controls; see [ChatGPT's setup guide](https://help.openai.com/en/articles/12584461-developer-mode-and-full-mcp-connectors-in-chatgpt).
## What you can do
| Area | Available capabilities |
| - | - |
| Workspace | View the connected business name, country, and business verification status. |
| Contracts | List contracts, view public summaries, and create drafts for completion in Shor. |
| Timesheets | Review submitted work, amounts, payment dates, and automatic payment settings; approve or reject it after confirmation. |
| Milestones | List milestones for a selected contract, review amounts and payment dates, and approve or reject submitted milestones after confirmation. |
| Payments | List payments and inspect their current status, scheduled date, and amounts. |
| Balances | View available and pending workspace balances with the time they were checked. |
The assistant receives selected workspace fields, not every detail visible in Shor. For example, a contract summary does not include the full signed agreement or a complete professional profile.
### Example prompts
* “Show submitted timesheets awaiting approval, including amounts, currencies, payment dates, and automatic payment settings.”
* “List my contracts, then show the submitted milestones for the contract I select.”
* “Show failed payments and their scheduled dates.”
* “What are my available balances, and when were they checked?”
* “Create a contract draft titled Website redesign for me to finish in Shor.”
* “Review this submitted timesheet and ask me to confirm before approving it.”
* “Reject this submitted milestone with the reason: The agreed deliverables are incomplete. Ask for my confirmation first.”
These are requests for the assistant to carry out using Shor's tools. A write still requires confirmation, appropriate access, and a supported assistant version. Lists may span multiple pages; ask the assistant to check every page when you need a complete review.
## Review actions before confirming
Every draft creation, approval, and rejection requires an explicit confirmation request from your assistant. Review the workspace and the exact proposed action.
For approvals and rejections, the confirmation includes the professional, contract, amount and currency, and payment date. Timesheet approvals also show automatic payment settings; milestone approvals explain that payment processing is attempted immediately. Rejections include your reason.
If the details change or the review expires, ask the assistant to fetch the latest information and show a new confirmation. If your assistant cannot display the required confirmation, complete the action in Shor.
Approving work can create a payment obligation. Timesheet payments follow their due date and effective automatic payment setting. Milestone approval attempts payment processing immediately. Approval does not mean the professional has been paid; check the resulting payment status.
Creating a contract draft does not sign or activate it. Finish the compensation, terms, review, and signing steps in Shor.
## What still happens in Shor
Use the Shor application to sign or activate contracts, edit existing contract terms, initiate a standalone payout, or manage bank connections. The current assistant tools do not expose full professional profiles, general search, upcoming-payment summaries, or webhook subscriptions.
A balance is a point-in-time observation. An unavailable balance is an error, not a zero balance or permission to spend.
## Permissions and disconnecting
Each connection belongs to the Shor membership and workspace used during sign-in. Connecting one workspace does not grant access to another. Available tools depend on the connection's permissions and your current role; role changes apply to subsequent requests. Approval and rejection require an admin role.
To review access, open **Settings → Integrations → Manage connection access**. This takes you to **Settings → API keys → MCP connections**, where admins can see the granted permissions, expiry, and connection status. Choose **Disconnect** to revoke an active hosted connection. Shor rejects subsequent requests using that revoked connection.
Never paste API keys or sign-in tokens into a conversation. Hosted setup handles sign-in without sharing those secrets in chat.
## Troubleshooting
| What you see | What to check |
| - | - |
| Setup is disabled | Ask a Shor workspace admin to configure the connection. |
| Remote setup is unavailable | Ask Shor whether integrations are enabled and the hosted endpoint is configured for your environment. |
| Sign-in succeeds but reads fail | Check that you selected the intended workspace and that your membership and connection are active. |
| A tool is missing | Check the granted permissions and refresh the assistant's tool list. |
| Reads work but actions fail | Confirm that your role allows the action, writes are enabled, and your assistant supports Shor's confirmation flow. |
| The confirmation is stale or expired | Fetch the current details and review a fresh confirmation before trying again. |
| The connection is disconnected or expired | Review its status in **MCP connections** and follow the setup instructions. If access remains blocked, contact Shor. |
For exact tool names, API routes, scopes, and error codes, see the [MCP tool reference](/developers/mcp). For a direct software integration, see the [Public API](/developers/public-api).
# Automating Payments
Source: https://docs.shorpay.com/employer/automation
Turn on auto-funding and auto-payments for a hands-off payroll cycle.
If you'd rather not click through payroll every cycle, Shor can run it for you. Two toggles in **Settings → Payments** control how hands-off your payroll becomes.
## The Two Toggles
When enabled, your linked bank account is automatically debited to cover upcoming payment obligations, plus any standing reimbursement float you've set in Settings → Payments. The debit is timed so funds are typically in place by the pay date, but bank transfers can take a few business days to settle, so Shor initiates them ahead of when they're needed.
When enabled, pending payments for eligible contracts are processed automatically on their due date, with no manual confirmation needed.
Both are **off by default** and require your explicit opt-in.
## Turning Automation On
Automation requires a connected funding source. Go to **Finance → Connections** and confirm you have an active bank connection.
From your workspace settings, go to the **Payments** tab.
Turn on **Automatic Funding** first. This is the debit side: money moves from your bank into your Shor virtual account before the pay date.
Turn on **Automatic Payments**. Once the funds are in place, Shor processes the underlying payments on the due date.
You can turn either toggle off at any time. Changes apply to future cycles; anything already in flight follows the setting that was active when it kicked off.
## What's Always Manual
Not every payment gets automated. Some things should always have a human in the loop:
Milestones are paid when you (or an approver) mark them complete. Auto-pay doesn't release milestones on its own; that would defeat the whole point of milestone-based work.
PAYG contractors submit timesheets for your approval. Those approvals are always manual: Shor won't pay hours you haven't approved.
Bonuses, commissions, reimbursements, and ad-hoc payments still go through the manual payment flow. The wizard surfaces them in **Finance → Payments**.
When a new contract activates, its first scheduled payment always needs your review before it processes, even if auto-pay is on. If you backdate a contractor's start date to earlier in the current month, each pay period that's already elapsed also gets its own payment, labeled **Catch-up** on the payment detail. Catch-up payments are no longer held for separate review: with auto-pay on they are funded and processed alongside your other scheduled payments, and with auto-pay off they wait for you to process them like anything else.
## Per-Contract Control
Beyond the workspace-level toggles, you can override auto-pay per contract from the Payroll page. This is useful for situations like:
* A contractor you want to review every time before paying
* A new hire whose payments you want to eyeball for the first couple of cycles
* A sensitive payment you want to always approve manually
## What to Watch For
Automatic funding needs your bank to clear debits in time. Keep an eye on the bank you connected, especially if you switch primary accounts.
If a worker updates their bank details, Shor pauses the next payment for them so you can confirm. Auto-pay resumes once the new details are verified.
Auto-pay doesn't silently retry failures. Anything that fails stays on the Payroll page with an error badge, waiting for you to fix and retry.
If your virtual account runs low, the next auto-fund debit may fail. Shor emails you before and after, and pauses subsequent payments until funding is healthy again.
## Visibility
Automated payments appear in the same **Finance → Payments** and **Finance → Transactions** views as manual ones, with the same detail: amount, rate, reference, destination, timestamps. You can filter, sort, and export them exactly the same way.
## Turning Automation Off
Flip either toggle off in **Settings → Payments** at any time. From that point, payroll returns to manual mode for new cycles. Any payments already scheduled for auto-processing finish on their existing setting.
## Next Steps
How the Payroll page works day-to-day.
Connect and manage funding sources.
# Billing
Source: https://docs.shorpay.com/employer/billing
How Shor bills you and how to manage your plan.
Shor charges a monthly subscription based on the workers on your account. This is separate from the money moving through Shor to pay those workers; that comes from your connected bank.
## How Pricing Is Structured
Your monthly bill is made up of up to four kinds of line items:
**\$19** / contractor / month. Same price regardless of country. Appears on your invoice as "X contractors".
**\$299** / employee / month for the 19 Standard Market countries. Appears as "Y employees, Standard markets".
**\$449** / employee / month for the 6 Premium Market countries. Appears as "Y employees, Premium markets".
**\$50–\$60** / employee / month for employees on an entity you own. Appears as "Y Managed Global Employees", grouped by country.
Full country tier breakdown is on the [Pricing](/pricing) page, and [Payroll on your own entity](/employer/managed-payroll) covers how managed payroll seats work. For volume discounts or custom plans, reach out to [sales@shorpay.com](mailto:sales@shorpay.com).
## Viewing Your Bill
Go to **Settings → Billing** to see:
* Your active subscription with a per-line-item breakdown
* The current month's projected total
* Every past invoice, downloadable as PDF
* A link to the billing portal for payment method and receipt details
## Managing Payment and Billing Details
Payment methods, billing address, and receipt preferences are managed in a secure external billing portal. Click **Manage billing** on the Billing page. It opens the portal in a new tab where you can:
* Update the card on file for monthly billing
* Change the billing email or address
* Download detailed invoices and tax receipts
* Cancel or pause the subscription
## How Active Workers Are Counted
A worker counts toward your bill in a given period if their contract is in the **active** state at any point during that period. If someone starts mid-month or offboards mid-month, they still count for that month.
Draft, pending signature, completed, cancelled, or offboarding contracts don't incur seat charges.
## Past Invoices
Every invoice is archived on the Billing page. Each shows:
* The billing period
* Line items by type (contractor seats, EOR seats and managed payroll seats grouped by country)
* Per-unit pricing and quantity
* Tax where applicable
* The final total
Invoices are formatted for clean upload to most accounting software, or just hand them to your accountant.
## Cancelling or Pausing
To offboard individual workers, use the offboarding flow on each worker's profile. The month an offboarding takes effect is still billed in full; the worker stops counting toward your bill from the following month, consistent with how active workers are counted above. To cancel your entire account, use the **Manage billing** portal or reach out to [support@shorpay.com](mailto:support@shorpay.com). Data export and final invoices are handled as part of the cancellation.
## Next Steps
See the current rate structure.
Workspace preferences and account controls.
# Compensation Types
Source: https://docs.shorpay.com/employer/compensation
Every way you can pay people on Shor.
Shor supports four compensation structures. Pick the one that matches how you and the worker have agreed to structure the engagement.
## The Four Types
A fixed recurring amount. Typical for full-time employees.
Paid per hour worked. Requires timesheet submission and approval. Used for Pay-As-You-Go contracts.
Paid when specific deliverables are accepted.
A fixed recurring amount for ongoing availability. Used for Fixed Rate contractor contracts.
## Picking the Right Type
* Full-time employees
* Predictable long-term contractors on a monthly fee
* Situations where you want a steady, predictable cash flow
* Consulting engagements with variable time commitment
* Contractors where you want to pay only for time actually worked
* Roles with a clear time-input-to-output relationship
* Project-based work with defined deliverables
* Engagements where you want to tie payment to outcomes
* Longer projects broken into phases
* Reserving a contractor's capacity without guaranteed work
* Fractional roles (fractional CFO, fractional designer)
* Situations where availability is as valuable as output
## Salary Units
For salary-based compensation, you can enter the amount as:
* **Per hour**: normalized to an annual equivalent
* **Per week**: for weekly pay cycles
* **Per month**: for monthly pay cycles (most common)
* **Per year**: an annual figure, divided across pay cycles
## Payment Frequency
For recurring compensation (salary, retainer), you pick how often to pay:
* **Weekly**: every seven days
* **Biweekly**: every two weeks
* **Monthly**: once a month
* **Daily** (Fixed Rate contractor retainers only): a payment every calendar day, including weekends
Monthly is the most common for global teams; weekly and biweekly are common for US hourly workers.
## First Payment Handling
For workers who start mid-period, you can choose:
* **Pro-rated**: automatically pay only for the days worked in the starting period
* **Custom** (Fixed Rate contractor contracts only): enter your own first-payment amount, useful for a sign-on bonus or back pay, capped at 12 times the recurring cycle amount
Most companies use pro-rated for fairness and accurate accounting. Daily retainers pay the same rate every calendar day, so there's no first-cycle proration to configure.
## Changing Compensation
To change a contractor's rate or structure, open their profile and amend the contract. Both parties sign the amendment and the new compensation takes effect on the date you specify. For employees, update compensation from their job information instead.
## Next Steps
Schedule recurring pay runs for your team.
Set up milestone tracking and payments.
# Contracts
Source: https://docs.shorpay.com/employer/contracts
How contracts work on Shor: creating, signing, and updating them.
Every engagement on Shor is backed by a contract. This page explains the contract types, how they get signed, and how to make changes once they're live.
## Contract Types
Shor generates contracts from templates matched to the engagement and country:
Full employment contract: at-will for US roles, or a country-appropriate employment framework elsewhere. Includes statutory benefits and withholdings.
A fixed-scope, fixed-price contractor agreement, good for retainers and well-defined projects.
A contractor agreement where payment is tied to delivering specific milestones.
The contractor submits timesheets and is paid for approved hours.
## Generating a Contract
Contracts are generated automatically when you add a new worker. Shor combines:
* The **worker's country**: for labor law, minimum wage, statutory clauses, and required disclosures
* The **engagement type** (employee vs. contractor): for which template to use
* The **compensation**: rate, currency, frequency
* The **governing law** you select: for dispute resolution and jurisdiction
The resulting contract is ready to send. You can edit specific fields (scope, custom clauses, start date) before sending, and even after sending as long as neither side has signed yet. For contractor contracts, editing at that point cancels the pending signature request and returns the contract to draft so you can review and resend it. For employees hired directly through Shor, terms can instead be edited in place until the employee accepts: the contract stays in its current state and doesn't need to be resent from scratch.
If you sent an employee contract to the wrong person or need to correct the recipient before they've accepted, open the contract and click **Withdraw** to return it to draft so you can fix it and send again.
If a contract is waiting on the worker's signature and you no longer want to proceed, select it in the contracts list (or open it) and click **Cancel**. The worker can no longer sign, and the contract is marked cancelled and stays visible in your list. Cancel is not available once both sides have signed, and for employees hired directly through Shor it is only available before the employee accepts. Workspace viewers see the control but can't use it.
## Signing
Most contracts are signed electronically. For contractor engagements (Fixed Rate, Milestone, Pay-As-You-Go), either side can sign first: your worker can sign as soon as their identity verification is approved, and you can sign before or after them. For employee contracts, you sign first, then the contract goes to the worker. In a few employee markets, local law requires the employment agreement to be signed in ink off this platform; Shor shows that on the contract instead of **Review & Sign**, and our local partner collects the signed copy. The flow:
Review the generated contract, make any final edits, and invite your worker to create their account.
Your worker verifies their identity before anyone can sign. Shor shows you their verification progress on the contract page.
For contractor engagements, click **Review & Sign** whenever you're ready; your worker may already have signed, or may sign after you. For employee contracts, click **Review & Sign** first.
Whoever hasn't signed yet gets notified: your worker by email if you signed first, or you on the contract page if your worker signed first. The contract becomes active on the agreed start date once both sides have signed.
Once both sides have signed, open the contract from the worker's profile to view or download the signed document.
## Amending a Live Contract
Sometimes things change: a rate update, a scope update, a new start date. For active contractor engagements, open the worker's profile and click **Amend**. Shor walks you through which fields can be changed and generates an amendment for both parties to sign. Employee contracts aren't amended this way; update an employee's terms from their job information instead.
If the engagement uses your own uploaded contractor agreement, click **Send for acceptance**. That send is your acceptance. You can attach an optional **Amendment PDF** for the contractor to read before they accept. The terms shown in Shor are what get applied. The contractor accepts from their contract page. Shor cannot assess whether those changes fit the legal terms of your own agreement.
Amendments are tracked as versions so you always have a clean history of what was agreed and when.
## Custom Clauses
You can add custom clauses to a contract: IP assignment, non-solicitation, confidentiality specifics, bonus structures. These are layered on top of the template and preserved in every version. EOR hires also use a separate company-wide IP assignment between your company and Shor. See [Hiring Employees](/employer/hiring-employees#company-ip-assignment).
## Governing Law
For the template language to be enforceable, the contract needs a governing jurisdiction. Shor currently supports:
* **United States**: Delaware, California, New York
* **Australia**: New South Wales, Victoria, Queensland
* **United Kingdom**
* **Singapore**
* **Other**: a generic framework for countries where Shor doesn't yet have a country-specific template
## Dispute Resolution
Each contract specifies how disputes are resolved, typically either **arbitration** or **court** in the governing jurisdiction. You can pick which applies when you generate the contract.
## Next Steps
How each pay structure works in practice.
Managing your team from the People tab.
# Finance Dashboard
Source: https://docs.shorpay.com/employer/finance
Your account balances, money movement, and connections.
The Finance tab is where you see and control every movement of money in your Shor account.
## What's in Finance
Your Shor virtual account: current balance, activity, and currency breakdown.
Bank accounts you've linked to Shor for funding.
Every payment you've sent, with status and receipts.
A detailed view of every money movement: debits, credits, and transfers.
## Accounts
Your **Shor virtual account** holds funds between being debited from your bank and being paid out to workers. It gives you:
* A running balance, updated in real time
* A per-currency breakdown if you run multi-currency payroll
* A complete history of movement in and out
* A dashed line on the balance chart marking your reimbursement float, if you've set one in Settings → Payments
## Connections
The **Connections** tab lists every bank account you've linked. For each, you'll see:
* The bank name and last four digits of the account
* Status: Connected, Pending, or Failed
* Whether it's your primary funding source
From this tab you can add a new bank account, mark one as primary, or disconnect one you no longer use.
## Payments
The **Payments** tab is the operational log of every payment you've sent:
* **Status**: pending, processing, completed, failed, cancelled
* **Recipient**: which worker received it
* **Amount** and currency
* **Type**: salary, hourly, milestone, bonus, commission, reimbursement
* **Reference**: any note you added when sending
Click any payment to see the full detail, including receipts and the transaction chain.
## Transactions
The **Transactions** tab is the accounting view: every debit, credit, and internal transfer. Use it for:
* Reconciling against your bank statement
* Exporting data to your accounting software
* Auditing money movement
* Tracking transaction statuses (initiated, processing, completed, failed)
Transaction types you'll see:
* **Deposit**: funds moving into your virtual account from a connected bank
* **Withdrawal**: funds leaving your virtual account to pay a worker
* **Transfer**: internal movement (e.g., currency conversion)
## Exporting Data
Every Finance view has an **Export** button. You can download CSV files by date range for:
* Payments
* Transactions
* Expenses
* Payroll runs
The CSV is formatted to be easy to hand to your accountant or import into your accounting software.
## Reconciliation Workflow
A typical month-end close on Shor:
Pull a CSV of all transactions in the period.
Every debit from your connected bank should match a corresponding deposit into your Shor account.
The total of payments going out should match the approved payroll runs for the period.
Shor platform fees and FX margin are itemized; pull them into your P\&L under the right category.
## Next Steps
Deeper look at the ledger view.
Manage payment methods and invoices.
# Funding Your Shor Account
Source: https://docs.shorpay.com/employer/funding
How to connect a bank account so you can pay your team.
Before you can pay workers, you need to connect a funding source so Shor has somewhere to pull money from. Today, that's done by connecting your company's bank account to the virtual account Shor creates for your business.
## How Funding Works
When your company is approved, Shor provisions a **virtual account** for you. This is a dedicated account Shor manages on your behalf and uses to send payments to your workers. You move money into it from an external business bank account that you connect.
Go to **Finance → Connections** and click **Connect Bank Account**. You'll be guided through a secure flow to link your business bank account.
Depending on your bank, verification happens either instantly via a login, or by confirming small test deposits that appear in your account.
Once the connection is active, Shor will debit the connected bank account when you approve a payroll or send a payment. You can also pre-fund your virtual account ahead of a large run.
## Your Virtual Account
Your virtual account is where funds sit between being debited from your bank and being sent to your workers. You can see the balance and movement in **Finance → Accounts**.
A dedicated virtual account gives each payment a clean audit trail, keeps your operating cash separate from your payroll float, and lets Shor handle multi-currency and international payouts without touching your primary bank.
Not usually. For most payrolls, Shor initiates the debit from your connected bank in time for funds to clear before the pay date. For large or time-sensitive runs, you can pre-fund to avoid any timing risk. For faster pre-funding, go to **Finance → Accounts**, click **Add Money**, and select **Fund with a wire** to view your Shor virtual account's routing and account details. Wire transfers typically arrive same day or next business day.
Workers can be paid in their local currency. Shor handles the conversion from your funding currency and shows you the FX rate before you confirm each payroll.
Yes. In **Settings → Payments**, you can set a standing reimbursement float: an extra balance automatic funding keeps in your virtual account on top of what's needed for upcoming payments, so instant reimbursements stay funded even during a payroll run. It's off by default and only applies while automatic funding is on. This isn't locked-up money; it's part of your normal virtual account balance.
## Payment Timing
Payment timing depends on the destination country and payout method. Shor shows you the estimated arrival date for every payment before you approve it.
If a bank debit fails (for example, because of insufficient funds) Shor pauses the affected payroll and emails you. The run resumes once funding is in place.
## Connections Tab
The **Finance → Connections** tab shows every bank account you've linked, its status, and which one is being used as your primary funding source. You can connect additional accounts at any time.
## Next Steps
With funding connected, you're ready to pay people.
See account balances and every payment that's moved.
# Hiring Contractors
Source: https://docs.shorpay.com/employer/hiring-contractors
Onboard independent contractors anywhere in the world.
Contractors are independent workers. They set their own hours, use their own tools, and typically work for multiple clients. This guide covers hiring and paying contractors through Shor.
## Before You Start
Have the following ready:
* The contractor's full legal name and email
* The scope of work and rate you've agreed on
* Your preferred payment cadence (per invoice, milestone, monthly retainer, etc.)
You don't need the contractor's country, tax ID, or bank details. They provide those themselves when they accept your invite.
## Adding a Contractor
From **Talent → People**, click **Add person**. Pick or invite the contractor by email, then choose **Contractor** and the contract type:
* **Fixed Rate**: set scope, set price, typically a project or retainer
* **Milestone**: paid when deliverables are accepted
* **Pay-As-You-Go**: paid by the hour against submitted timesheets
Define the project:
* **Project name**: what you're hiring them for
* **Department**: which team the work sits under
* **Start date**: when the engagement begins. For Fixed Rate and Pay-As-You-Go contractors, you can set a date earlier in the current month if work already started; Shor will hold a separate payment for review for each pay period that's already passed
* **Milestones** (Milestone contracts only): titles, deliverables, and amounts
Add any custom clauses on top of Shor's localized template.
Enter the rate and currency for the contract type you chose:
* **Pay-As-You-Go**: hourly rate, paid against approved timesheets
* **Fixed Rate**: the recurring retainer amount
* **Milestone**: individual milestone amounts (set in the Agreement step)
For Pay-As-You-Go contracts, pick weekly, biweekly, or monthly. Fixed Rate also offers Daily: one payout every calendar day, including weekends.
Review everything, eyeball the contract Shor generates, and click **Send for signature**.
## What the Contractor Does Next
Once you send the contract, your contractor receives an email to:
1. Create a Shor account
2. Pick whether they're signing as an **individual** or through a **business entity** (this affects the contract template and which US tax form applies)
3. Complete identity verification: a single secure session that collects their government ID, selfie, residential address, and phone number. Country of residence comes from the ID's nationality.
4. Sign the contract, including the correct US tax form (W-9, W-8BEN, or W-8BEN-E) if required for your engagement
5. **Optionally** link a bank account for withdrawals. Each payment lands in their Shor account within minutes, and they can withdraw to their own bank when they want
You'll see their progress on the worker's profile in real time.
## Paying Contractors
Depending on the contract type:
Payments are auto-generated on the schedule you set and appear on the Payroll page as upcoming. Process them manually, or enable auto-pay so they process on the due date without you clicking in.
Open the worker's contract, review the submitted milestone, and approve it. The milestone payment is released to the contractor (manual by design; auto-pay doesn't release milestones).
The contractor submits timesheets for review. You approve or reject each one from the Payroll page. Approved timesheets become payments ready to process.
## Contractor Classification
Misclassifying a worker as a contractor when they should be an employee can create serious tax and legal liability, especially in countries with strong worker-protection laws.
If you're unsure whether to hire as a contractor or employee, reach out to [support@shorpay.com](mailto:support@shorpay.com) before sending the contract. Our team can walk through the engagement and recommend the right classification based on the country and scope.
## Tax Forms
For US tax reporting:
* **W-9**: collected from US persons (citizens, residents, US entities)
* **W-8BEN**: collected from foreign individuals
* **W-8BEN-E**: collected from foreign entities
Shor collects the right form at contractor onboarding and stores it on the worker's profile.
## Next Steps
Deeper look at every compensation type.
Set up and manage milestone-based work.
# Hiring Employees
Source: https://docs.shorpay.com/employer/hiring-employees
Hire full-time and part-time employees globally.
Hiring an employee is different from hiring a contractor: employees are part of your company, they receive statutory benefits, and there are local payroll taxes and protections to honor. Shor handles the compliance so you can focus on picking the right person.
This page covers hiring through **EOR**, where Shor is the legal employer. If you already own an entity in the country, you can employ the person through it instead and have Shor run the payroll, at a much lower monthly fee. See [Payroll on Your Own Entity](/employer/managed-payroll).
## When to Hire an Employee vs. a Contractor
* They work set hours for your company
* You direct how the work gets done
* They use your equipment and systems
* The relationship is ongoing and exclusive
* Their country's labor law requires employee status for the role
* They work for multiple clients
* They set their own schedule and methods
* They use their own tools
* The engagement is project-based or short-term
## Adding an Employee
From **Talent → People**, click **Add person** and pick **Employee**, then set the country of employment.
If you have an active subsidiary registered in that country, a **Payroll Employer** choice appears: your subsidiary, or **Shor EOR**. Pick **Shor EOR** to have Shor employ the worker on your behalf.
If you don't have a subsidiary there, this choice doesn't appear and the hire goes through EOR.
This affects required benefits, tax thresholds, and the contract template Shor generates.
Enter the job title and seniority level. Shor uses this for contract language, pay benchmarks, and any country-specific role classification.
Enter the salary and unit (per hour, per week, per month, or per year) along with the currency.
Weekly, biweekly, or monthly, matched to local norms for the worker's country.
Pick the jurisdiction the contract is governed by. Shor defaults to the worker's country employment law framework, with localized clauses for probation, notice, statutory benefits, and termination.
Shor generates a country-appropriate employment contract reflecting local labor law. Review and send for signature. The summary also includes the company IP assignment described below.
## Company IP Assignment
On an EOR contract summary, Shor asks a company representative to review and sign a **Company IP Assignment** between your company and Shor. You do this once. The completed agreement applies across your EOR hires.
Click **Review and sign IP Assignment**. You can keep inviting employees while your company's signature, or Shor's countersignature, is still pending. If the agreement is still being prepared, you can keep hiring and sign once it is ready. When it is on file, choose **Download agreement** from the same step. If it is declined or expires, contact support to arrange a new one. Viewers see the step with signing disabled.
## Start Date on the EOR Agreement
The start date on an EOR contract follows the date on the EOR agreement while the contract is still a draft, awaiting signature, or signed and not yet active. If that date changes, Shor updates the contract and emails you and the employee that the start date moved to match the EOR contract. When the contract is already signed and those payments have not started processing, Shor rebuilds the upcoming payments from the new date.
## What the Employee Does Next
Your new hire receives an invitation to:
1. Create their Shor account
2. Submit identity verification. Employee requirements stay locked until they do
3. Save personal, tax, and payroll details while verification is in review. These answers are drafts and do not accept the contract. Supporting document uploads are requested after verification is approved
4. Finish any remaining requirements after verification is approved, including their bank account, then sign the employment contract (electronically in most countries; in ink off this platform where local law requires it)
Shor verifies the payroll information with the worker's country payroll system before the employee can finish signing; this can take a few minutes.
In some countries, Shor's local partner contacts the employee directly to collect any remaining paperwork and finalize the agreement, instead of the employee signing in the app. When this applies, you and the employee both see a waiting item on your dashboards until the partner completes the handoff.
Once they finish onboarding, they appear as an active worker on your People list and their upcoming payments surface automatically on the Payroll page based on their pay schedule.
## Statutory Benefits and Withholdings
For EOR (Employer of Record) employees, Shor handles the country-specific requirements:
* **Statutory leave**: annual, sick, maternity, paternity as required by local law
* **Public holidays**: tracked automatically
* **Employer contributions**: pension, social security, health insurance where mandated
* **Employee withholdings**: income tax and statutory contributions deducted from each paycheck
* **13th / 14th month pay**: where required by law
You'll see a breakdown of total employer cost (salary + contributions + fees) before you finalize the contract, so there are no surprises. You can download this breakdown as a PDF to share internally.
## Probation, Notice, and Termination
Every employment contract reflects the country's rules for:
* **Probation period**: maximum length permitted
* **Notice period**: required notice on both sides, which typically scales with tenure
* **Severance**: statutory severance where applicable
* **Mandatory end-of-employment filings**: any local filings required when the engagement ends
When an employment ends, start an offboarding from the worker's profile. Shor walks you through notice periods, final pay, and any required local filings.
## Where Shor Supports Employees
Employee support varies by country. Some countries support full EOR (Shor employs the worker on your behalf); others only support contractor engagements today. A subset of our employee markets also supports managed payroll on an entity you own.
See which countries support employee hiring.
Hire through your own local entity instead.
How salary, hourly, and variable pay work.
# Payroll on Your Own Entity
Source: https://docs.shorpay.com/employer/managed-payroll
Run payroll through a subsidiary you already own, instead of hiring through EOR.
If you already have a legal entity in the country where you're hiring, you don't need an Employer of Record. Register the entity with Shor as a subsidiary, and Shor runs payroll on top of it: gross-to-net calculation, statutory filings, and tax remittance, in the same dashboard as the rest of your team.
This is called **managed payroll**, and it costs **\$50–\$60 per employee per month** instead of the \$299–\$449 you'd pay for EOR, because you're already carrying the entity.
## Managed Payroll vs. EOR
The difference that matters most: **who is the legal employer**. With EOR, it's Shor. With managed payroll, it's you.
| | Your subsidiary | Shor EOR |
| - | - | - |
| **Legal employer** | Your local entity | Shor |
| **Monthly fee** | \$50–\$60 / employee | \$299–\$449 / employee |
| **Employment agreement** | You provide it, already signed | Shor generates a localized contract |
| **How the employee accepts** | Accepts your agreement in Shor | Signs in Shor, or in ink off-platform where local law requires it |
| **Gross-to-net payroll** | Shor | Shor |
| **Statutory filings and tax remittance** | Shor | Shor |
| **Statutory registration details** | You provide them for your entity | Handled on Shor's entity |
| **Countries available** | 15 markets | Every [EOR market](/platform/global-coverage) |
Managed payroll is the cheaper option, but it assumes you've already done the expensive part: incorporating locally and keeping that entity in good standing. If you don't have an entity in the country and don't want to set one up, use [EOR](/employer/hiring-employees) instead.
## Where Managed Payroll Is Available
Managed payroll runs in 15 markets today. It requires that Shor can operate the full payroll lifecycle locally, so it covers fewer countries than EOR.
### Tier A Markets: \$60 / Employee / Month
| Asia | Latin America | North America | Europe | Middle East |
| - | - | - | - | - |
| India | Brazil | Canada | Germany | United Arab Emirates |
| | Mexico | | United Kingdom | |
### Tier B Markets: \$50 / Employee / Month
| Asia | Latin America | Africa |
| - | - | - |
| Pakistan | Chile | Ghana |
| Philippines | Colombia | Kenya |
| | | Nigeria |
| | | South Africa |
If your country isn't listed, you can still hire there through [EOR](/employer/hiring-employees) where it's supported, or [book a call](https://shor.cal.com/shor/shor-intro-call) and we'll tell you where it sits on the roadmap. See [Global Coverage](/platform/global-coverage) for the full country directory.
## Setting Up a Subsidiary
Before you can hire onto your own entity, register it in Shor.
Go to **Settings → Company → Subsidiaries** and click **Add subsidiary**. Only admins can add or edit subsidiaries; other roles can view them.
**Legal name** and **Country** are required. The country list only shows markets where managed payroll is available.
Optionally add the legal structure, incorporation date, registration number, and tax ID. Fill these in if you have them — they feed the statutory filings Shor makes on your behalf.
Both are used for statutory filings when payroll runs under this subsidiary. Add a local contact number that payroll and compliance follow-up can reach.
Open the subsidiary and work through the **Employer Requirements** section. These are the statutory registration details your entity needs on file to run payroll — employer registration numbers, social security or pension scheme identifiers, and similar. Exactly which fields appear depends on the country.
This step blocks hiring, so it's worth doing as soon as the subsidiary is created rather than mid-contract.
You can't change a subsidiary's country after it's created. Everything else stays editable. If you registered an entity in the wrong country, add a new one and contact [support@shorpay.com](mailto:support@shorpay.com).
## Hiring onto Your Subsidiary
Once the subsidiary is active, hiring works like a normal employee hire with two differences: you pick who runs payroll, and you supply the employment agreement.
From **Talent → People**, click **Add person** and pick **Employee**, then set the country of employment.
A **Payroll Employer** choice appears with two options: your subsidiary, or **Shor EOR**. If you have more than one subsidiary in that country, pick which one.
This option only shows up when you have an active subsidiary in the same country as the employee. If you don't see it, check that the subsidiary is registered in that exact country and that managed payroll is available there.
Salary, pay frequency, role, and start date work exactly as they do for EOR employees. See [Hiring Employees](/employer/hiring-employees) for the detail on each field.
The cost estimate shows a **Managed payroll service fee** instead of the EOR fee, alongside the employer contributions calculated for that country.
Because your entity is the legal employer, Shor doesn't generate the contract. Upload the employment agreement your entity is using, already signed. Shor stores the PDF and asks the employee to accept it in-app.
The summary shows any outstanding **Employer Requirements** for the subsidiary and the worker. You can't send the agreement until they're complete. When everything's green, click **Send for acceptance**.
## What the Employee Does
Your new hire receives an invitation to:
1. Create their Shor account
2. Complete identity verification
3. Provide the personal, tax, and payroll details their country requires, including their bank account
4. Accept the employment agreement you uploaded
The one difference from EOR: the employee **accepts** your agreement rather than signing a Shor-generated contract electronically. The legal agreement is between them and your entity, so Shor records acceptance rather than acting as a party to it.
Once they finish onboarding, they appear as an active worker on your People list and their payments surface on the Payroll page on their pay schedule, alongside your contractors and EOR employees.
## Running Payroll
After onboarding, there's nothing special to do. Employees on your subsidiary appear on the same [Payroll](/employer/payroll) page, fund from the same account, and use the same local payment rails as everyone else on Shor. Payslips are generated the same way.
Shor calculates gross-to-net for the country, withholds employee contributions, and handles the statutory filings and tax remittance under your entity's registrations.
## Billing
Managed payroll seats are billed per employee per month, separately from EOR and contractor seats.
* Your invoice shows them as **"Y Managed Global Employees in "**, grouped by country
* A partial first month is charged as a one-time item, then the seat moves onto your regular monthly cycle
* A seat is counted while the contract is active, on the same rules as every other worker type
See [Billing](/employer/billing) for how the full invoice is put together, and [Pricing](/pricing) for the current rates.
## Common Questions
There's no in-place switch, because the legal employer changes. In practice it means ending the EOR employment and hiring the person onto your entity under a new agreement, which local labor law may constrain. Talk to [support@shorpay.com](mailto:support@shorpay.com) before you start so we can sequence it without a gap in pay.
Yes. The Payroll Employer choice is per contract, so you can run some employees on your subsidiary and hire others through Shor EOR in the same market.
Yes. Every employee on your entity needs a signed agreement uploaded, because your entity is the party to it. Most companies reuse one localized template per country.
Three things need to be true: the subsidiary is **Active**, it's registered in the same country as the employee, and managed payroll is available in that country. The Payroll Employer choice is hidden entirely when none of your subsidiaries qualify.
Admins can add and edit them. Other roles can view subsidiary details but can't change them. See [Inviting Your Team](/employer/team) for roles.
## Next Steps
The full employee hiring flow, including EOR.
Every country Shor supports, by model.
Where subsidiaries live in your workspace.
How managed payroll seats appear on your invoice.
# Milestones
Source: https://docs.shorpay.com/employer/milestones
Pay contractors as they deliver specific outcomes.
Milestones tie payments to outcomes. Instead of paying on a schedule, you pay when a specific deliverable is completed and accepted. This page covers setting up milestones and approving them.
## When to Use Milestones
Milestones work well for:
* Project-based contractor engagements
* Design sprints, product launches, or research projects
* Engagements where you want to reduce risk by paying incrementally
* Freelancers who prefer to work against clear deliverables
They work poorly for:
* Ongoing retainers or fractional roles
* Hourly consulting where scope shifts frequently
* Employee relationships (use salary instead)
## Creating a Milestone Contract
Milestones are set up when you first add the contractor:
In the worker add flow, choose **Milestone** as the compensation.
For each milestone, add:
* A clear title and description
* The deliverable that must be completed
* The amount paid on completion
* An optional target date
Shor bundles all milestones into the contract. The contractor sees the full list of milestones and amounts when they sign.
## Milestone Statuses
| Status | What it means |
| - | - |
| **Pending** | Milestone is defined but work hasn't started |
| **Submitted** | Contractor has submitted the deliverable for review |
| **In review** | You're reviewing the submission |
| **Approved** | You've accepted the deliverable; payment is queued |
| **Completed** | Milestone is done |
| **Paid** | Payment has landed with the contractor |
| **Rejected** | Deliverable was rejected; the contractor can resubmit |
## Reviewing and Approving a Milestone
When work is done, your contractor opens the milestone and clicks **Submit for review**. They can attach deliverables (files, links, notes).
You get a notification. Open the milestone and review the submission.
* **Approve**: the milestone moves to approved, and payment is queued.
* **Reject**: send it back with feedback. The contractor can revise and resubmit.
Once approved, the milestone payment is released per the contract's payment terms. You'll see it in **Finance → Payments**.
## Adding Milestones Mid-Contract
If scope expands, you can add new milestones to a live contract. Open the worker's profile, click **Amend contract**, and add the new milestones. Both parties sign the amendment.
## Partial Payments and Holdbacks
For large milestones, some teams pay a percentage upfront and the rest on completion. You can structure this as two milestones (e.g., "Phase 1: 30% upfront" and "Phase 2: 70% on delivery") rather than using a single milestone with a partial payment.
## Next Steps
The full contractor onboarding flow.
For payments outside milestones.
# Company Onboarding & Verification
Source: https://docs.shorpay.com/employer/onboarding
Get your company verified and ready to hire.
Before you can pay people through Shor, your company needs to complete business verification. This is a regulatory requirement, and it keeps the platform safe for everyone while unlocking the full range of countries you can hire in.
## How Verification Works
Click **Start Verification** from the onboarding screen and a guided, secure session walks you through six sections:
Country of incorporation, legal business name, state registration number, tax ID (EIN for US companies), and website. We'll search public registries to pre-fill what we can.
Your registered business address — country, street, city, state, and postal code.
Business phone (with country code) and a contact email.
A few questions about the business: company size, primary source of funds (VC/equity, revenue, loans, grants, etc.), whether you're a payroll provider paying on behalf of clients, how you plan to use Shor (paying contractors, paying employees, or both), anticipated monthly payroll volume, and annual revenue range.
Add everyone who needs to be verified: **Beneficial Owners** (25%+ ownership), **Controlling Persons**, and any **Authorised Representatives**. For each person you provide their name, date of birth, ownership percentage, and shares allocated. You can then either **verify them right there** (upload their government ID + address) or **invite them by email** so they can self-serve. Bulk "Invite all via Email" is available too.
Upload the four required documents: **Certificate of Incorporation**, **Bank Statement**, **Proof of Address** (issued within the last 3 months), and **Tax Registration Document**. Shor validates each upload against the expected document type on the spot.
Once you've submitted everything — company info, ownership details, and the four required documents — the case is handed to **Shor's compliance team** for review. They run their own checks on top of the automated verification, and you'll get an email when the review is complete (or if anything needs clarification). Most straightforward cases are approved within one business day.
Edits to your company or ownership details after verification is approved will trigger re-verification. Get the details right the first time where you can.
## What to Have Ready
Before you start, gather:
* Certificate of Incorporation (or equivalent registration)
* Recent Bank Statement
* Proof of Address issued within the last 3 months (utility bill, bank statement, or lease)
* Tax Registration Document (EIN letter for US, or country equivalent)
* Legal business name and country of incorporation
* State registration number (US) or equivalent
* Tax ID (EIN for US, or country equivalent)
* Business website
* Names and ownership percentages for every Beneficial Owner (25%+)
* Date of birth and shares allocated for each
* Email addresses if you'd rather invite them to self-verify
* Government-issued ID for anyone you'll verify in-session
* Company size and annual revenue range
* Primary source of funds
* Anticipated monthly payroll volume
* Whether you act as a payroll provider for other clients
## Starting and Resuming
If you need to step away mid-verification, you can close the window and come back to pick up where you left off; your progress is saved. When you return, the **Start Verification** button becomes **Continue Verification**.
## Verifying Beneficial Owners
For each Related Person you add, Shor offers two paths:
You collect their ID issuing country, ID type (passport, driver's license, national ID), front and back document photos, and residential address right in your session. Fastest if everyone's in the room.
Shor emails the person a secure link to submit their own ID and address. Best when your co-founders or owners aren't available to sit with you. You can invite individuals or send bulk invites with "Invite all via Email."
## Common Reasons for Delays
Your Proof of Address must match the registered address you entered. If you moved recently, upload a bank or utility statement issued within the last 3 months.
Every person with 25%+ ownership must be listed as a Beneficial Owner. Missing one will block approval until it's added.
Each upload slot expects a specific document (Certificate of Incorporation, Bank Statement, Proof of Address, Tax Registration Document). If the system flags "Document uploaded does not match the selected document type," make sure you're uploading the right file in the right slot.
Bank statements and utility bills used as Proof of Address must be from the last 3 months. Registration and tax documents just need to be the most recent version.
Screenshots of phone screens, cropped images, or anything with hidden fields will fail review. Upload the full, unedited document as a PDF or clear photo.
If you sent an "Invite via Email" to a Beneficial Owner, verification won't finish until they submit their ID and address. Resend the invite from the Ownership Details step if needed.
## After Verification
Once verified, you're ready to:
* Connect a bank account to fund payments
* Invite your admin team
* Add your first worker and send a contract
* Run payroll and send payments
## Next Steps
Connect a bank account so payments can move.
Start building your team.
# One-Off Payments
Source: https://docs.shorpay.com/employer/one-off-payments
Send a payment outside the regular payroll schedule.
Not every payment fits into a payroll cycle. Bonuses, reimbursements, consulting fees, and ad-hoc payments are sent as one-off payments from the **Finance → Payments** tab.
Only teammates with the **Admin** role can send, process, or cancel payments. **Members** and **Viewers** can view payments and track their status. See [team roles](/employer/team#roles) for access details.
## When to Use a One-Off Payment
Paying a contractor outside their normal cycle, for an extra invoice or a quick engagement.
A one-off project or short-term consulting fee.
Covering a business expense a worker paid out of pocket.
A one-time discretionary or performance bonus.
## Sending a One-Off Payment
The payment wizard is four quick steps:
Start from **Finance → Payments** and click **Send payment**. Search your team and pick a recipient. Their payout details pull in automatically. Off-cycle payments require either an active contract or a completed payment history with your business; if you enter an email with no contract on file, the wizard prompts you to start a contract for that person first.
Enter the amount. The currency is fixed to the recipient's contract compensation currency and can't be changed here. The wizard shows the estimated arrival amount for the recipient (including any FX conversion and fees) so there are no surprises.
Pick a **purpose** for the payment (Reimbursement, Contractor Payment, Freelance Work, Consulting, or Bonus) and add a reference note that appears on the worker's receipt.
Review everything, then confirm. Shor queues the payment and debits your connected bank account.
## Processing Multiple Payments at Once
The payment wizard sends one payment at a time. When you need to move several payments together (end-of-month reimbursements, a batch of contractor invoices, quarterly bonuses) use the **Payroll page** (**Talent → Payroll**) instead. Select the rows you want, and Shor processes them as a single approved batch.
## Payment Requests From Your Team
A contractor or employee can also [request an ad-hoc payment](/professional/payment-requests) from you directly, instead of you initiating it. Requests appear inline in **Finance → Payments** alongside your own one-off payments (and on your dashboard attention list when one is waiting).
As a **business admin**, you can **approve** a pending request (Shor creates the payment and begins processing it right away) or **deny** it with a reason. Team members can view requests, but only admins can approve or deny. You can't edit the requested amount, purpose, notes, or attachments; it's approve as submitted or deny.
If the worker's contract has ended or its currency changed since they submitted, Shor cancels the request instead of creating a payment, and the worker is notified.
## Idempotency
If you retry a submission or the page refreshes mid-request, Shor prevents duplicates using idempotency keys on every payment. You won't accidentally pay someone twice.
## Tracking One-Off Payments
One-off payments appear in:
* **Finance → Payments**: the canonical list of everything sent
* **Finance → Transactions**: every debit and credit recorded
* The worker's profile under **Payments**
* The Payroll page, alongside scheduled payments
Each payment has a status (pending, processing, completed, failed, cancelled) and a receipt you can download.
If a pending payment's funding pull does not settle, it stays **Pending**. Open it and you'll see **Funding did not settle**, with the reason **Funding deposit failed. Fund and retry this payment.** **Process payment** stays available. While funding is still in progress, the detail shows **Funding in progress** and the payment continues once that funding settles. The same notices appear on the [Payroll](/employer/payroll) page.
## Next Steps
How workers request ad-hoc payments from you.
For contractor milestone payments with an approval flow.
Handling expense reimbursements properly.
Process batches of payments at once.
# Employer Overview
Source: https://docs.shorpay.com/employer/overview
A tour of the Shor dashboard for companies.
The employer dashboard is where you hire, pay, and manage your global workforce. This page covers the main sections and what each one is for.
## Dashboard Sections
A snapshot of your team: active workers, upcoming payrolls, recent payments, and anything that needs your attention.
Everything related to your people: hiring, contracts, payroll, and individual worker profiles.
Your money movement: funding sources, one-off payments, transactions, and account balances.
Company profile, team members, billing, bank accounts, and workspace preferences.
## Your First Week
If you're new to Shor, here's a typical setup path:
Finish business verification so you can start paying people.
Connect a bank account so payments have somewhere to pull from.
Add teammates who need access: finance, HR, founders. Assign roles from Settings → Users.
Start with one person to get familiar with the flow. Send a contract and watch the onboarding happen end-to-end.
Many companies send a small first payment to confirm everything is wired up before scaling.
## Team Members
You can invite teammates (co-founders, finance, HR) to access your Shor workspace. Each person has a role that controls what they can see and do:
* **Admin**: full access to hiring, contracts, payroll, payments, funding, and settings.
* **Member**: standard access for day-to-day team members.
* **Viewer**: read-only access to every page and record; can't create, send, or approve anything.
The person who signs up the company starts as an Admin. You can invite new teammates and set roles from **Settings → Users**.
## Where to Go Next
KYB, funding, and getting ready to hire.
Walk through adding contractors and employees.
# Payroll
Source: https://docs.shorpay.com/employer/payroll
Process scheduled and upcoming payments for your team.
The **Talent → Payroll** page is where your team's money actually moves. It's a unified view of everything that's ready to pay: scheduled salary and fixed-rate payments, timesheet approvals, and anything already in flight.
Only teammates with the **Admin** role can approve or reject timesheets, approve milestones, or process or cancel payments. **Members** can view payroll and reject milestones. See [team roles](/employer/team#roles) for access details.
## What You'll See on Payroll
The page combines three kinds of entries into a single list:
For salaried employees and fixed-rate contractors, Shor auto-generates the next payment based on the contract's compensation and schedule. They appear as **upcoming** until you process them.
For pay-as-you-go contractors, submitted timesheets show up here for an Admin to review. Once approved, they become payments ready to process.
Payments that have been queued, are in flight, or have already landed. Useful for tracking status and reconciling.
## Processing a Batch of Payments
Use filters (employment type, contract type, payment type, keyword) to narrow the list to what you want to process. Select the rows via the checkboxes: one, many, or everything on the page.
Click **Process payments**. Shor shows a summary: how many payments, which currencies, total amount, and anything that requires attention (insufficient funds, missing tax info).
Confirm to kick off the batch. Shor processes each payment: for upcoming entries, it generates the underlying payment first; for pending ones, it releases them.
The dialog tallies successes and failures, with a specific reason for anything that didn't go through. Successful payments move to **Processing**; failed ones stay on the list with an error badge so you can fix and retry.
## Payment Statuses on Payroll
| Status | What it means |
| - | - |
| **Upcoming** | A scheduled payment from a contract, not yet generated or processed |
| **Pending** | Generated and queued, waiting to be processed or funded |
| **Processing** | Funds are moving to the worker |
| **Completed** | Arrived in the worker's account |
| **Failed** | Didn't go through; see the error detail and retry |
| **Cancelled** | Cancelled before being processed |
## Insufficient Funds
If your connected bank doesn't have enough to cover a batch, Shor stops before initiating any payment and prompts you to fund. Any payments that started before the shortfall are already in flight; the rest stay pending until you add funds.
## Funding That Does Not Settle
A pending payment whose funding pull does not settle stays **Pending**. Open it and you'll see **Funding did not settle**, with the reason **Funding deposit failed. Fund and retry this payment.** **Process payment** stays available so you can add funds and try again.
While a funding pull is still in progress, the same detail shows **Funding in progress**. The payment continues on its own once that funding settles.
## Automating Payroll
For teams that don't want to manually process every cycle, Shor has two toggles in **Settings → Payments**:
Automatically debits your connected bank account the evening before upcoming payments are due.
Processes upcoming salary and fixed-rate payments on their due date without manual confirmation.
See [Automating payments](/employer/automation) for how to turn these on and the guardrails that come with them.
Milestone releases and timesheet approvals always need an Admin's sign-off, regardless of the auto-pay setting: Shor won't release a milestone or pay unapproved hours on its own. Once an Admin approves a timesheet, the resulting payment follows your normal auto-pay setting like any other scheduled payment.
## Common Scenarios
Shor generates a prorated first payment based on their start date, unless their contract opts for the full amount. The upcoming payment appears on the Payroll page like any other. If you backdate a contractor's start date to earlier in the current month, Shor also creates a payment for each pay period that's already passed, labeled **Catch-up**. These follow your normal auto-pay setting: they process automatically if auto-pay is on, and wait for you to process them if it isn't.
Start an offboarding from the worker's profile. Shor calculates final pay, any owed items, and adds it to the payroll list for processing.
Leave them unselected when you batch-process. Their upcoming payment stays on the list until you're ready, or until you update their contract.
Failed payments stay on the Payroll page with an error badge. Click in for the specific reason (usually a bank detail mismatch or insufficient funds), fix it, and reprocess.
## Next Steps
Set up auto-funding and auto-payments.
For payments outside the scheduled payroll flow.
Release milestone payments as work is completed.
# People Overview
Source: https://docs.shorpay.com/employer/people
The People tab is where you manage everyone on your team.
The **Talent → People** tab is the hub for everyone you're paying through Shor: contractors, employees, and anyone in between. This page explains what you'll see and how to use it.
## The People List
Every worker you've added appears here with:
* **Name and role**: who they are and what they do
* **Country**: where they work from, which drives compliance and pay
* **Engagement type**: contractor or employee
* **Contract status**: draft, pending signature, signed, active, offboarding, completed, or cancelled
* **Next payment**: their upcoming pay date and amount
Click a person's name to open their detailed profile.
## Adding Someone New
From the People tab, click **Add person**. Shor's wizard walks you through four steps:
Pick or invite the professional by email, and choose whether they're a **Contractor** or **Employee**.
* For contractors, pick the contract type: Fixed Rate, Milestone, or Pay-As-You-Go.
* For employees, pick the Country of Employment (gated to countries where Shor offers EOR), then the Payroll Employer: Shor EOR, or one of your own [subsidiaries](/employer/managed-payroll) if you have an active one in that country.
Define the engagement.
* For contractors: project name, department, and start date (and milestones if applicable).
* For employees: job title, seniority, department, employment terms, and governing law.
The compensation type is set by the contract type chosen in the Start step: hourly for Pay-As-You-Go, retainer for Fixed Rate, milestone for Milestone, and salary for employees. Enter the rate, pick a currency, and set the payment frequency.
Review the generated contract, add any custom clauses, and send it for signature.
You only provide the worker's name and email up front. They set their own country (for contractors), personal details, tax info, and payout method when they accept the invite.
See the dedicated guides for more detail:
For independent workers paid per invoice, milestone, or retainer.
For full-time workers with statutory benefits and withholdings.
## Worker Profiles
Open any person to see:
* **Contract**: the live agreement and every past version
* **Compensation**: rate, currency, and payment schedule
* **Payments**: every payment sent, with status and receipts
* **Documents**: signed contracts, tax forms, and uploaded attachments
* **Timeline**: a chronological view of every event tied to this worker
## Contract Lifecycle
A contract moves through these states:
| Status | What it means |
| - | - |
| **Draft** | You've started a contract but not sent it yet |
| **Pending signature** | Sent to the worker; awaiting both signatures |
| **Signed** | Fully executed but not yet active |
| **Active** | Live engagement; the worker can be paid |
| **Offboarding** | Termination initiated; wrap-up in progress |
| **Completed** | Engagement ended cleanly |
| **Cancelled** | Contract voided before activation |
## Offboarding
When an engagement ends, start an **Offboarding** from the worker's profile. Shor walks you through:
* Final pay and any owed reimbursements
* Notice period and termination date (respecting local labor law)
* Document retention and access revocation
* Any country-specific termination steps
## Next Steps
Deeper details on contract types and pay structures.
Set up recurring pay runs for your team.
# Expense Reimbursements
Source: https://docs.shorpay.com/employer/reimbursements
Reimburse workers for business expenses they've covered.
When workers spend their own money on business expenses (travel, equipment, software), Shor handles the reimbursement flow end-to-end.
## How Reimbursements Work
From their dashboard, the worker uploads a receipt, enters the amount, picks a category, and adds a note about what it's for.
You get a notification. Open the expense, check the receipt, and approve, reject, or ask for more info.
Approved expenses are added to the worker's next pay cycle, or can be paid out immediately as a one-off reimbursement.
## Expense Statuses
| Status | What it means |
| - | - |
| **Submitted** | Worker has submitted the expense; awaiting your review |
| **Approved** | You've approved it; queued for payment |
| **Rejected** | You've declined it; the worker can revise and resubmit |
| **Paid** | Reimbursement has been sent |
## Expense Categories
Every expense gets a category for reporting and accounting:
* **Travel**: flights, hotels, ground transport
* **Equipment**: laptops, monitors, peripherals
* **Meals**: client dinners, team meals
* **Software**: subscriptions, licenses
* **Training**: courses, conferences, certifications
* **Office supplies**: consumables and small equipment
* **Other**: anything that doesn't fit the above
Your accountant can export expenses by category for month-end close.
## Setting Expense Policies
Keep reimbursements consistent with a clear expense policy. Common guardrails:
* Per-diem caps for meals and travel
* Equipment purchase limits (e.g., "up to \$2,000 per person per year")
* Approval thresholds (e.g., "expenses over \$500 need a second approval")
* Required documentation (receipts, pre-approval for travel)
You enforce the policy in the approval step: Shor surfaces the receipt and details so you can check against your policy before approving.
## Payment Timing
Approved expenses are added to the next payroll run for that worker. Clean for accounting, but the worker waits until the next pay date.
Approve and pay as a one-off reimbursement. The worker gets their money faster, but it's a separate transaction in your books.
## Tax Treatment
Reimbursements are generally not taxable income for the worker, as long as they're backed by valid receipts and are for legitimate business expenses. Shor stores every receipt alongside the payment for your records.
Tax treatment varies by country. If you have questions about a specific reimbursement, check with your tax advisor. Shor's role is to provide clean records, not tax advice.
## Next Steps
Other types of ad-hoc payments.
See every transaction in one place.
# Settings
Source: https://docs.shorpay.com/employer/settings
Workspace preferences, team, payments, integrations, and API access.
The Settings tab is where you manage your workspace configuration. This page is a quick tour of what's there.
## Settings Sections
Your personal account details and security (password, multi-factor authentication).
Team members with access to your workspace and their roles.
Connected bank accounts used to fund your virtual account. Links into Finance → Connections.
Automation toggles for funding and payments. See [Automating payments](/employer/automation).
Your Shor plan, active worker count, and invoices.
Choose email and Slack delivery for each category of employer update.
Light / dark / system theme for your workspace.
Legal entities your business owns, used for payroll in countries where you have a local presence. See [Payroll on your own entity](/employer/managed-payroll).
Export your account data and make privacy requests. See [Data privacy](/platform/data-privacy).
Connect Slack, QuickBooks, and AI assistants.
Manage API credentials and access granted to AI assistants.
## Profile
Your personal account settings, separate from your company's workspace settings. Two sections:
* **Personal details**: information associated with your Shor account.
* **Security**: manage your password and multi-factor authentication.
## Users
Invite teammates and set their role. See [Inviting your team](/employer/team) for details on roles and best practices.
## Bank Accounts
The Bank accounts tab takes you to **Finance → Connections**, where you manage every bank account linked to Shor. You can add new connections, see their status, and set a primary funding source. See [Funding your Shor account](/employer/funding) for the full flow.
## Payments
The Payments tab controls how hands-off your payroll is. Two toggles:
* **Automatic funding**: debits your connected bank the evening before payments are due
* **Automatic payments**: processes scheduled salary and fixed-rate payments on their due date
Both are off by default. Turn them on once you've run a few manual cycles and know your workflow is stable. See [Automating payments](/employer/automation).
## Billing
Your subscription details and invoices. Payment methods and billing address are managed in an external billing portal linked from the page. See [Billing](/employer/billing).
## Appearance
Pick **Light**, **Dark**, or **System** (which follows your OS preference).
## Subsidiaries
Manage the legal entities your business owns. Subsidiaries are local legal employers in foreign countries that you can use for payroll instead of Shor acting as the employer of record.
Admins can add a subsidiary with its legal name, country, legal structure, incorporation date, registration number, tax ID, registered address, and a local phone number. The country list is limited to markets where Shor supports managed payroll, and the country can't be changed once the subsidiary is created. Other roles can view subsidiaries but not edit them.
Each subsidiary also has an **Employer Requirements** section for the statutory registration details needed to run payroll in that country. Complete it before hiring, since it blocks employees from accepting their agreement.
Once a subsidiary is active, it can be selected as the payroll employer when creating employment contracts in that country. See [Payroll on your own entity](/employer/managed-payroll) for the full flow.
## Data
Export your account data — contracts, payments, and tax records — or make a privacy request (access, correction, or deletion). See [Data privacy](/platform/data-privacy) for what Shor collects and how it's protected.
## Integrations
In **Settings → Integrations**, admins can connect Slack, connect QuickBooks, and set up AI assistants such as Claude, ChatGPT, or Cursor.
For Slack, choose **Add to Slack** and approve workspace access. Once connected, send Shor a direct message in Slack and follow the account-linking flow so Shor can deliver updates to you.
For QuickBooks, choose **Connect QuickBooks** and approve access for the company you want to use. After it is connected, choose **Set up sync**, pick the environment that matches that company, and select a bank or clearing account plus a default expense account. You can also set **Categories by payment type**. Shor records completed payments in the company's home currency as paid expenses. This does not send money. Choose **Sync payment** or **Sync all unsynced** to export eligible payments yourself, or turn on **Sync payments automatically** to record newly settled payments about every five minutes. Payments that were already eligible when you turn that on stay manual, and a failed sync needs **Retry sync**. **Change category** updates that existing expense only. On a completed payment, the QuickBooks icon shows the same sync status. **Disconnect** stops new syncs. Expenses already recorded in QuickBooks stay there. Members can see the connection. The page says **Only admins can manage QuickBooks** for everyone else.
For AI assistants, choose **Set up** under **AI assistants**, follow the instructions in your assistant, and sign in to the intended Shor workspace. See [Connect AI assistants](/employer/ai-assistants) for setup, supported actions, example prompts, and access controls.
## Notifications
Choose email and Slack delivery separately for each category of employer update in **Settings → Notifications**. Both channels start enabled, and your choices apply only to you in the current workspace. You can set preferences before connecting Slack; Slack delivery starts once the workspace is connected and your account is linked.
## API keys
In **Settings → API keys**, admins can create, rotate, and revoke API credentials for enabled workspaces. Copy a new key when it is shown; it cannot be retrieved later. See [Public API](/developers/public-api) for scopes, expiry, and integration guidance.
The same page includes **MCP connections**, where admins can manage AI assistant access. **Manage connection access** in Integrations takes you there. Connecting an assistant through the hosted sign-in flow creates its connection automatically; you do not need to create an API key for it.
## Account Notifications
Shor sends important account notifications (KYB updates, funding failures, billing reminders) to the email you signed up with. Make sure it's an address that gets monitored, not a personal account that could be missed.
From **Settings → Notifications**, you can also choose Email, Slack, both, or neither for each notification category: timesheets and approvals, payments and balances, contracts, and account and billing. Both channels start enabled. Slack delivery begins once your workspace is connected to Slack and you've linked your own account there; these preferences are personal to you and don't change what your teammates receive.
## Closing Your Account
If you're leaving Shor, reach out to [support@shorpay.com](mailto:support@shorpay.com). We'll walk you through:
1. Offboarding any remaining active workers
2. Exporting your data (contracts, payments, tax records)
3. Issuing the final invoice
4. Closing the virtual account
## Next Steps
Invite and manage teammates.
Set up auto-fund and auto-pay.
# Inviting Your Team
Source: https://docs.shorpay.com/employer/team
Add co-founders, finance, and HR to your Shor workspace.
You're rarely the only person who needs access to Shor. This guide covers adding teammates, setting roles, and keeping access tidy as your team changes.
## Inviting a Teammate
Click your profile, go to **Settings**, and select the **Users** tab.
Enter your teammate's email address and pick a role.
Your teammate receives an email with a link to create their account. They'll land in your workspace as soon as they finish signup.
## Roles
Shor has three access levels for company teammates:
Full access: hiring, contracts, payroll, payments, funding, billing, and settings. Use for founders, finance leads, and senior HR.
Standard access for day-to-day team members who need to work in Shor but shouldn't manage funding or billing. Only Admins can approve or reject timesheets, approve milestones, or process or cancel payments. Members can still reject milestones.
Read-only access to every dashboard page and record. Can't create or sign contracts, invite teammates, link bank accounts, withdraw funds, run payroll, or approve timesheets and milestones. Use for auditors, investors, or advisors who only need visibility.
The person who signs up the company is automatically an Admin. At least one Admin must exist on the account at all times.
## Managing Existing Teammates
From **Settings → Users**, you can:
* **Change a role**: switch between Admin, Member, and Viewer.
* **Resend an invite**: if a teammate didn't receive the original email.
* **Remove access**: when someone leaves the company or changes roles.
Removing access is immediate. The person will be signed out of the workspace right away. Make sure any in-progress work (payroll runs, contract drafts) is handed off before removing them.
## Best Practices
Start new teammates as Members and upgrade to Admin only when their role requires it. This reduces the chance of accidental changes to funding or billing.
If your only Admin leaves the company, you'll have a harder time recovering access. Always have a backup Admin on the account.
Once a quarter, open the Users page and confirm everyone on the list still needs access. This is also a good time to verify roles haven't drifted out of date.
# Timesheets
Source: https://docs.shorpay.com/employer/timesheets
Review and approve time submitted by Pay-As-You-Go contractors.
For **Pay-As-You-Go** (PAYG) contracts, contractors submit their hours each pay period. You review and approve, and approved hours flow into the next payment.
## Where Timesheets Show Up
Submitted timesheets appear in two places:
**Talent → Payroll** shows submitted timesheets alongside upcoming payments and in-flight work. Filter by employment type or contract type to focus on just PAYG entries.
Open the specific PAYG contract from **Talent → People** to see its full timesheet history, including past approved/rejected cycles.
## Timesheet Statuses
| Status | What It Means |
| - | - |
| **Submitted** | Contractor has submitted hours; awaiting your review |
| **Approved** | You've approved the timesheet; the hours roll into the next payment |
| **Rejected** | You've sent it back with feedback; the contractor can revise and resubmit |
## Reviewing a Submitted Timesheet
Click the submitted timesheet from the Payroll page, or open it from inside the contract's detail view.
You'll see:
* The contractor's name and contract
* The pay period (start and end dates)
* Hours submitted
* Rate × units total
* Any notes the contractor added
* **Approve**: the timesheet moves to Approved and the hours flow into the next scheduled payment. You'll see the resulting line item on the Payroll page.
* **Reject**: add a reason (required). The contractor gets an email with your feedback and can revise and resubmit.
## What Happens After Approval
The approved timesheet generates a payment line item with the amount = `rate × units`. That payment appears on the Payroll page and follows the normal payroll flow:
* Shows up as an upcoming payment on the Payroll page
* Gets processed on the next scheduled pay date (or when you click **Process payments**)
* Debits your connected bank account and credits the contractor's Shor account within minutes once funded
* Appears in **Finance → Payments** and **Finance → Transactions** like any other payment
## Bulk Review
If multiple PAYG contractors submit in the same pay cycle, you can review them all from the Payroll page. Filter to the pay period, check each submission, approve or reject, and then batch-process the approved ones as a single payroll run.
## Rejecting With Feedback
Rejection isn't punishment. It's a clarification loop. Common reasons:
* Hours don't match what you agreed on for the period
* Missing detail in the notes (which project, which client meetings)
* Task was outside the contract's scope
* Typo or wrong unit count
Always include a **reason** when you reject. The contractor sees it verbatim and knows exactly how to revise.
## Timesheet History
Each contract's detail view keeps the full history: submitted timesheets, approvals, rejections, associated payments. Use this for:
* Reconciling against your own records of approved work
* Year-over-year totals per contractor
* Auditing disputes ("what did we pay for last month?")
## Common Scenarios
If a contractor submits after the pay period has closed, the timesheet still needs your review, but the resulting payment goes out on the next scheduled pay date, not the missed one. Communicate the delay directly if it affects them.
Don't silently approve what you don't agree with. Reject with a specific number you'll approve, the contractor resubmits, and both sides have a written trail.
If your contract has tiered rates, the timesheet captures units at the contracted base rate. For overtime line items, coordinate with the contractor. Often cleanest as a separate one-off payment rather than stuffed into a timesheet.
If the submitted work goes beyond the original scope, you have two paths: approve and pay (accepting the scope creep), or reject and renegotiate the scope first (then resubmit). Decide based on your relationship and what's been formally agreed.
They should ask you before submitting. The submission form shows `rate × units = total` using the contract's base rate. If the real answer is different, get it clarified upfront.
## Automation Limits
Timesheets are **always manual to approve**, even with [auto-pay](/employer/automation) enabled on the workspace. Auto-pay applies to already-approved payments on a contract schedule; it doesn't approve timesheets on your behalf. Approval is a human judgment call, and Shor treats it that way.
Once a timesheet IS approved, the resulting payment can flow through auto-pay if that's your setting.
## Next Steps
How approved timesheets flow into payments.
Setting up a PAYG contract in the first place.
The other path for deliverable-based work.
# Transactions
Source: https://docs.shorpay.com/employer/transactions
The detailed record of every money movement.
The **Transactions** tab shows every debit and credit in your Shor account. If **Payments** is the operational view ("I sent \$5,000 to Maria"), **Transactions** is the accounting view ("\$5,000 was debited from the funding account and credited to Maria's payout account").
## What You'll See
Each transaction has:
* A **type**: deposit, withdrawal, or transfer
* A **status**: pending, initiated, processing, completed, or failed
* An **amount** and **currency**
* A **source** and **destination** account
* A **timestamp** and a link to the payment or payroll that triggered it
## Transaction Types
Money moving into your Shor virtual account, typically from a connected bank you've linked as a funding source.
Money leaving your virtual account to pay a worker or cover a fee.
Internal movement: currency conversion, re-allocation between sub-accounts, or rebalancing.
## Transaction Statuses
| Status | What it means |
| - | - |
| **Pending** | Queued but not yet started |
| **Initiated** | Kicked off with the underlying rail |
| **Processing** | Moving, typically waiting on bank clearing |
| **Completed** | Funds have landed in the destination |
| **Failed** | The transaction didn't complete; see details for the reason |
## Filtering and Searching
The Transactions list supports filters for:
* Date range
* Type (deposit, withdrawal, transfer)
* Status
* Currency
* Specific worker or payroll
Combine filters to answer questions like "show me all failed withdrawals in EUR last month" in one query.
## Exporting for Accounting
Click **Export** to download transactions as CSV. The export includes every field shown in the UI plus accounting-friendly columns (reference ID, GL mapping hints, source account, destination account).
Most teams export monthly and import into their accounting software as part of month-end close.
## Tracing a Payment End-to-End
Click any transaction to see the full chain:
* The **payment** that triggered it
* The **payroll run** or **one-off payment** it was part of
* The **contract** and **worker** it relates to
* Any **sub-transactions** (e.g., FX conversion, fee deduction)
This makes it easy to answer "where did this \$1,234 come from and why" in a single click.
For a payroll debit or an automatic funding deposit, the detail view also includes a **What this covers** breakdown. A payroll debit itemizes net pay, tax and statutory deductions, pension and employer contributions, and the processing fee. An automatic funding deposit itemizes the obligations it was pulled for (upcoming payroll, EOR security deposits, or both), less anything already in your balance, so the line items reconcile to the amount transferred.
## Common Questions
A cross-currency payment might show as: deposit (in your home currency) → transfer (FX conversion) → withdrawal (in the worker's currency). Each leg is recorded for a clean audit trail.
Processing time depends on the destination country's rail: minutes on instant rails like UPI, FPS, or PIX; same day to a couple of business days on standard local transfers; and 1–3 business days for ACH in the US. If a transaction sits in Processing much longer than expected, click it for details or reach out to support.
Platform fees and FX margin appear as separate transactions, itemized per payment. You can filter to see all fees in one view.
## Next Steps
The full Finance dashboard.
Understand Shor's own billing.
# How Shor Works
Source: https://docs.shorpay.com/how-it-works
From hiring to paying: the full lifecycle on Shor.
Shor handles the end-to-end lifecycle of building a global team: onboarding the worker, generating a compliant contract, collecting tax and identity information, running payments on a schedule, and producing the right tax documents at year-end.
## The Lifecycle at a Glance
Create your Shor account, complete business verification (KYB), and add funding so you can pay your team. Most companies are ready to hire within a day.
Invite a contractor or employee by email. You pick the engagement type (contractor or employee) and, for employees, the country of employment and who employs them: Shor as your Employer of Record, or a local entity you already own. The worker provides their own country, tax info, and payout details when they accept the invite.
Shor creates a contract that reflects local labor laws (including minimum wage, statutory leave, notice periods, and required clauses). Both parties usually sign electronically. In a few employee markets, local law requires the employment agreement to be signed in ink off this platform; our local partner collects that copy. If you're employing through your own entity, you upload your own signed agreement instead and the worker accepts it in Shor.
The worker completes identity verification (KYC). They can link a bank account at any time to withdraw earnings from their Shor account to their own bank.
Schedule recurring payroll runs, pay by milestone, or send one-off payments. Shor handles FX, withholdings, and local tax reporting automatically.
Every payment, contract, and invoice is stored in one place so you can reconcile at month-end and hand clean records to your accountant. US tax forms (W-9, W-8BEN, W-8BEN-E) are generated automatically for workers who need them.
## Two Portals, One Platform
For company admins: hire people, run payroll, manage funding, view reports, and handle billing.
For workers: sign contracts, view pay history, download invoices and tax documents, update payout methods.
## What Shor Handles for You
Every contract reflects the worker's country: probation periods, notice terms, non-competes, statutory benefits, and required disclosures. You don't need a lawyer in every jurisdiction.
KYC for workers and KYB for companies, with the right checks for each country. Shor handles re-verification when rules change.
Pay in 100+ local currencies. Workers receive their pay in the currency they want, with transparent FX.
For US contractors, Shor collects the right tax form (W-9 for US persons, W-8BEN for foreign individuals, W-8BEN-E for foreign entities) at onboarding. For employees on full EOR, Shor handles statutory withholdings where applicable. All records are stored and audit-ready.
Labor laws change. Minimum wages go up, tax thresholds shift, new statutory benefits are introduced. Shor tracks the changes so your contracts and payroll stay current.
## Contractors vs. Employees
Choosing the right engagement matters. Misclassification can create tax and legal liability.
Independent workers with their own tools and schedule. Paid per invoice, milestone, or retainer. No statutory benefits. Simpler onboarding, lower cost.
Full-time workers integrated into your company. Paid on a regular payroll schedule. Receive statutory benefits, tax withholding, and protected notice periods.
Unsure which applies? Reach out to [support@shorpay.com](mailto:support@shorpay.com) before sending the contract — our team can recommend the right classification based on the worker's country and role.
### Two Ways to Employ
Classification and employment are separate decisions. Once someone is an employee, you choose who legally employs them:
Shor employs the worker on your behalf in their country. Nothing to set up locally. Priced per employee per month by market tier.
You stay the legal employer through a local entity you already own, and Shor runs payroll on top of it at a lower monthly fee. See [Payroll on your own entity](/employer/managed-payroll).
## Where Shor Operates
Shor supports contractor payments in almost every country and full employee hiring (EOR) across a growing list of countries, with managed payroll on your own entity available in a subset of those markets. See the full breakdown in [Global Coverage](/platform/global-coverage).
## Next Up
Set up your company and run your first payment.
Create your profile and get paid.
# Welcome to Shor
Source: https://docs.shorpay.com/index
Hire, pay, and manage your global workforce from one place.
## What Is Shor?
Shor is a global payroll and hiring platform. We help companies hire employees and contractors anywhere in the world (handling contracts, compliance, payments, and taxes) so you can focus on building your team instead of managing paperwork.
Whether you're paying a full-time engineer in India, a design contractor in Brazil, or a freelancer in the US, Shor gives you one place to do it all.
### What You Can Do With Shor
Pay contractors in almost any country, and hire full employees through Shor's EOR across a growing list of markets, all with compliant, localized contracts.
Pay your team on a schedule in their local currency, with the right tax forms and statutory withholdings handled where applicable.
Built-in KYC, KYB, and country-specific labor rules keep you on the right side of local law.
A single dashboard for contracts, payments, invoices, and tax documents.
## Get Started
Pick the guide that matches your role:
Set up your company, add your team, and run your first payment.
Create your profile, sign your contract, and get paid on time.
## Popular Guides
A walkthrough of hiring, paying, and compliance on Shor.
Simple per-worker pricing with no hidden fees.
Where Shor can hire and pay workers today.
## Why Teams Choose Shor
Most payroll tools force you to choose. Shor handles contractors, full-time employees, and everything in between, in the same dashboard, with the same billing.
Hire employees through Shor's EOR in countries like India, the UK, Brazil, and the Philippines, and pay contractors almost anywhere else. We handle local contracts, tax forms, and statutory benefits so you don't have to become a labor law expert in every country.
Workers receive their pay on time, in their preferred currency, with clear pay stubs and invoices. You get a single view of every payment across the business.
Role-based access, audit trails, and reporting designed for how remote-first companies actually operate, not bolted onto 20-year-old HR software.
## Need Help?
* **Email:** [support@shorpay.com](mailto:support@shorpay.com)
* **Launch the app:** [app.shorpay.com](https://app.shorpay.com)
* **Website:** [shorpay.com](https://shorpay.com)
# Data Privacy
Source: https://docs.shorpay.com/platform/data-privacy
What personal data Shor collects, who can see it, and how it's protected.
To move money on behalf of companies and workers, Shor has to handle a lot of personal data: IDs, addresses, tax IDs, bank details, contracts. This page explains what we collect, why, and how it's protected.
## What We Collect
* Full legal name
* Date of birth and residential address
* Government ID (photo and details)
* Tax identification number and residency
* Bank account or payout method details
* Employment history as needed for contracts
* Legal business name and registration
* Registered address and tax ID
* Beneficial ownership information
* ID and address details for the authorized signer
* Business description and expected activity
## Why We Collect It
Required by regulation for any platform that moves money. Prevents identity theft, money laundering, and sanctions violations.
Contracts need accurate names, addresses, dates, and jurisdictions to be legally valid.
Bank details and tax IDs are required by banking and tax infrastructure to move money correctly.
US tax forms (W-9, W-8BEN, W-8BEN-E) are collected because they're required by the IRS for US businesses paying contractors.
## Who Can See What
Access is scoped tightly:
| Data | Who can see it |
| - | - |
| **Your verification status** (verified / pending / failed) | You and your employer(s) |
| **Your identity documents** (ID photos, selfie) | You and Shor's verification team (NOT your employer) |
| **Your contract details** | You and the specific company that contract is with |
| **Your payment history with Company A** | You and Company A |
| **Your payment history with Company B** | You and Company B (not Company A) |
| **Your tax form** | You and the specific employer who requires it |
| **Your bank details** | You and Shor's payment operations (NOT your employer) |
Your data is never shared between employers. Each company sees only the information relevant to their own engagement with you.
## How We Protect It
* **Encryption in transit and at rest**: every piece of personal data is encrypted with industry-standard algorithms
* **Access controls**: Shor staff can only see data on a need-to-know basis, with every access logged
* **Tenant isolation**: each business's data is isolated from every other business
* **Retention limits**: we keep data only as long as needed for legal, tax, and regulatory purposes
## Your Rights
Depending on where you're based, you may have specific rights over your data: access, correction, deletion, portability, and objection to processing.
Shor respects GDPR, CCPA, and equivalent frameworks. To exercise any right:
* **Access or export**: from **Settings → Data** in your account
* **Correction**: most fields are editable from your profile directly
* **Deletion**: reach out to [privacy@shorpay.com](mailto:privacy@shorpay.com)
* **Questions**: same email; we'll reply within regulatory timeframes
Some data must be retained even after account closure: for example, transaction records required by tax and anti-money-laundering regulations. We'll always tell you which data has to be kept and for how long.
## Connected Accounting
Connecting QuickBooks is optional. A workspace admin does it in **Settings → Integrations**. When it is connected, Shor sends completed payment amounts, currencies, dates, payment types, and the accounting accounts and categories the admin selected, so those payments can be recorded as expenses in that QuickBooks company. Shor does not receive the Intuit password.
Disconnecting QuickBooks stops new syncs. Expenses already recorded in QuickBooks stay there, and Shor keeps its sync records so the same payment is not exported twice if you reconnect. To ask about those retained records, email [privacy@shorpay.com](mailto:privacy@shorpay.com).
## Third-Party Processors
Shor uses third-party services to provide the platform: cloud hosting, identity verification, payment rails, email delivery, and, when an admin connects it, QuickBooks. Every processor is:
* Contractually bound by data protection commitments equal to or stronger than Shor's own
* Reviewed for security posture before use
* Only given the minimum data needed to perform their function
A current list of processors is available on request.
## Data Residency
For customers who require their data to be stored in a specific region (EU, US, etc.), Shor offers data residency options on enterprise plans. Contact [sales@shorpay.com](mailto:sales@shorpay.com).
## Incident Notification
If a data breach affects your information, we'll:
* Notify you within regulatory timelines (typically 72 hours in jurisdictions like the EU)
* Explain what happened, what data was affected, and what we're doing about it
* Provide guidance on any action you should take
## Questions
For anything privacy-related, email [privacy@shorpay.com](mailto:privacy@shorpay.com). For urgent issues, use [security@shorpay.com](mailto:security@shorpay.com).
## Next Steps
How Shor keeps the platform secure.
Why we collect what we collect.
# Global Coverage
Source: https://docs.shorpay.com/platform/global-coverage
Where Shor can pay workers and hire employees today.
Shor's coverage splits into three layers:
You can pay independent contractors in almost every country. The only exclusions are places subject to applicable US sanctions (OFAC).
For full employee hiring, Shor operates as your Employer of Record across a growing list of countries, in two pricing tiers, with more added each quarter.
Already have a local entity? Shor runs payroll on it and you stay the legal employer. Available in a subset of our employee markets.
## Paying Contractors
You can onboard and pay independent contractors in virtually any country in the world. To pay a contractor, you need:
* The contractor's email (to send the invite)
* A signed contract on Shor's localized template
* The contractor's completed profile, KYC, and bank account, which they provide themselves when they accept the invite
Shor handles the local payment rails and FX automatically. Every payment is screened against sanctions lists before it's sent.
**Sanctioned jurisdictions are excluded.** Shor can't send payments to countries or regions under comprehensive US sanctions (OFAC): currently Cuba, Iran, North Korea, Syria, Belarus, and specific regions of Russia and Ukraine. These lists can change; if a payment can't be made, Shor flags it before you confirm.
## Hiring Employees (Full EOR)
Full EOR (Employer of Record) means Shor employs the worker on your behalf in their home country, so you don't need to set up a local entity. Shor handles:
* Localized employment contracts
* Statutory benefits (leave, holidays, maternity/paternity where applicable)
* Income tax withholding and employer contributions
* Country-specific termination rules and severance
* Required local filings
EOR is available today across two pricing tiers. See [Pricing](/pricing) for full plan details.
### Standard Markets: \$299 / Employee / Month
| Asia | Latin America | Africa | Middle East |
| - | - | - | - |
| India | Argentina | Ghana | United Arab Emirates |
| Indonesia | Brazil | Kenya | |
| Nepal | Chile | Nigeria | |
| Pakistan | Colombia | Rwanda | |
| Philippines | Guatemala | South Africa | |
| | Mexico | Uganda | |
| | Peru | | |
### Premium Markets: \$449 / Employee / Month
| Europe | North America | Asia-Pacific |
| - | - | - |
| Finland | Canada | Singapore |
| Germany | | |
| Italy | | |
| Netherlands | | |
| Switzerland | | |
| United Kingdom | | |
Don't see your country in the live list? Check the coming-soon markets below or email [sales@shorpay.com](mailto:sales@shorpay.com). We prioritize new EOR countries based on customer demand.
## Payroll on Your Own Entity (Managed Payroll)
If you already own a legal entity in the country, you don't need an EOR. Register it with Shor as a subsidiary and we run payroll on top of it: gross-to-net calculation, statutory filings, and tax remittance. You remain the legal employer, and the cost drops to \$50–\$60 per employee per month.
Managed payroll requires Shor to operate the full payroll lifecycle locally, so it covers fewer countries than EOR.
### Tier A Markets: \$60 / Employee / Month
| Asia | Latin America | North America | Europe | Middle East |
| - | - | - | - | - |
| India | Brazil | Canada | Germany | United Arab Emirates |
| | Mexico | | United Kingdom | |
### Tier B Markets: \$50 / Employee / Month
| Asia | Latin America | Africa |
| - | - | - |
| Pakistan | Chile | Ghana |
| Philippines | Colombia | Kenya |
| | | Nigeria |
| | | South Africa |
See [Payroll on Your Own Entity](/employer/managed-payroll) for how to register a subsidiary and hire onto it.
## More Countries Coming
**Our roadmap is driven by where our customers actually need to hire.** The countries below are on deck. If your market is here, we can often fast-track it for a committed customer.
| Europe | Americas | Asia-Pacific | Africa & Middle East |
| - | - | - | - |
| Albania | Bolivia | Armenia | Bahrain |
| Belgium | Costa Rica | Australia | Egypt |
| Bosnia & Herzegovina | El Salvador | Azerbaijan | Israel |
| Croatia | Honduras | Georgia | Ivory Coast |
| Czech Republic | Panama | Japan | Jordan |
| Denmark | Paraguay | Kazakhstan | Kuwait |
| Estonia | Uruguay | Malaysia | Lebanon |
| France | | New Zealand | Morocco |
| Greece | | South Korea | Oman |
| Hungary | | Sri Lanka | Qatar |
| Ireland | | Taiwan | Saudi Arabia |
| Latvia | | Thailand | South Sudan |
| Lithuania | | Vietnam | Tanzania |
| Macedonia | | | Tunisia |
| Norway | | | Zambia |
| Poland | | | Zimbabwe |
| Portugal | | | |
| Romania | | | |
| Serbia | | | |
| Slovakia | | | |
| Slovenia | | | |
| Spain | | | |
| Sweden | | | |
| Turkey | | | |
| Ukraine | | | |
Your input genuinely moves countries up the queue. If you have a concrete hiring plan, let us know.
Drop us a note with the countries you need. We'll share timing.
30 minutes to talk through your hiring plans and see if we can help.
## What Each Model Covers
* Localized independent contractor agreement
* Local payment rails
* Appropriate US tax form collection (W-9, W-8BEN, W-8BEN-E)
* Year-end 1099 filing for US contractors
* Compliant invoicing and records
* Shor employs the worker on your behalf
* Statutory benefits and contributions handled
* Income tax withheld at source
* Country-specific employment contract
* Local statutory filings
* You remain the legal employer
* Gross-to-net payroll run on your entity
* Income tax withheld at source
* Statutory filings and tax remittance
* You supply the employment agreement
## Next Steps
Full plan details and competitor comparison.
How Shor routes payments in each country.
How taxes and withholdings are handled.
# Identity Verification (KYC & KYB)
Source: https://docs.shorpay.com/platform/kyc-kyb
How Shor verifies companies and workers.
Before anyone can send or receive money through Shor, they go through identity verification. Companies complete **KYB** (Know Your Business), and workers complete **KYC** (Know Your Customer). This keeps the platform compliant and, more importantly, safe.
## Why This Matters
Identity verification prevents:
* **Payments to the wrong person** (identity theft, impersonation)
* **Money laundering** through fake shell companies or ghost workers
* **Sanctions violations** (paying someone on a restricted list)
* **Tax evasion** (paying someone who shouldn't be working in a given country)
Skipping it isn't an option for any regulated payments platform. And even without the regulation, you wouldn't want money flowing through a system without basic identity checks.
## KYB for Businesses
Every business on Shor goes through KYB during onboarding. We verify:
We check your registration against the relevant government registry and confirm you're in good standing.
The person completing verification must be able to bind the company — typically a director, officer, or authorised agent.
Every Beneficial Owner (25%+ ownership) and any Controlling Persons are disclosed and verified, as required by regulations in most jurisdictions.
We check the business description, source of funds, expected payroll volume, and whether you're a payroll provider for other clients against high-risk categories that would require extra review.
## What You Need for KYB
* **Certificate of Incorporation** (or equivalent registration)
* **Bank Statement**
* **Proof of Address** issued within the last 3 months (utility bill, bank statement, or lease)
* **Tax Registration Document** (EIN letter for US, or country equivalent)
* ID and address details for every Beneficial Owner, Controlling Person, and Authorised Representative
* Company details, source of funds, expected payroll volume, and how you'll use Shor
## KYC for Workers
Every worker going through KYC provides:
Passport, driver's license, or national ID. Verified against the issuing authority where possible. The ID establishes legal name, date of birth, and nationality.
A real-time photo that confirms the ID matches the person creating the account, blocking impersonation.
Your current address, confirmed against your ID where possible. Some countries require a recent utility bill or bank statement as additional proof.
For account security and payment notifications.
Tax forms (W-9, W-8BEN, W-8BEN-E) are collected **separately during contract signing**, not during KYC. Which form applies depends on the worker's tax residency and whether they contract as an individual or a business entity.
## Ongoing Monitoring
Verification isn't a one-time event. Shor:
* Re-screens workers and businesses against sanctions lists regularly
* Triggers re-verification when high-risk changes are detected (large payment volume increase, new beneficial owner, change of business jurisdiction)
* Lets you update your own records at any time (a new address, a new owner, a new tax ID) from your profile
## Timing
**Worker KYC**
* **Automated verification** (the default path) usually finishes in minutes once the worker submits their ID and selfie
* **Manual review** (when automated checks can't resolve something) typically completes within 1-2 business days
**Business KYB**
* Every submission is reviewed by **Shor's compliance team** after the automated checks, so approvals are not instant
* Straightforward cases (single jurisdiction, complete documents, no sanctions hits) are typically approved within one business day
* **Complex cases** (multi-jurisdiction entities, unusual ownership structures, high-risk industries) may take longer; we'll always email you if we need more information
## Privacy of Verification Data
Your identity documents and beneficial ownership information are encrypted and accessed on a need-to-know basis. Your employer sees your **verification status** (pending, verified, failed), not the documents themselves. See [Data privacy](/platform/data-privacy) for more.
## What Happens If Verification Fails
You get a specific, actionable email. Typical reasons:
* Blurry, cropped, or expired documents → upload clearer, current versions
* Address mismatch → update your profile or upload a proof-of-address that matches
* Name mismatch between ID and account → ensure the name on your Shor profile matches your legal ID exactly
* Sanctions or PEP hit → case-by-case, usually requires manual review and additional information
For **worker KYC**, a decline also surfaces immediately in the app: the onboarding screen explains what likely went wrong and offers a **Try Again** button (to start a fresh session) and a **Contact Support** button, so you don't have to wait on the email.
If we're temporarily unable to reach the verification service, that's shown separately from a decline: you'll see a message that Shor is retrying automatically, or to contact support if it keeps happening. This isn't a failure on your part, and no action is needed unless it persists.
If something's blocking you that you think is wrong, reach out. Manual review exists for exactly these cases.
## Next Steps
How Shor protects data and money overall.
Who can see what on Shor.
# Money Movement
Source: https://docs.shorpay.com/platform/money-movement
How funds flow from Employer to Professional through Shor, and from Professional to their bank.
Shor moves money in two distinct stages: **employer → worker** happens inside Shor (typically a couple of minutes); **worker → bank** is a separate, worker-initiated withdrawal. This page explains both.
## The Path of a Payment
When an employer approves a payroll or payment, Shor debits their connected bank account (ACH in the US, equivalent rails elsewhere) and moves the funds into the employer's Shor account.
The contract specifies the currency the worker is paid in. If the employer's Shor account doesn't hold enough of that currency, Shor converts from their funding currency at a disclosed rate, shown before approval. The margin is a flat 2% above the interbank rate, disclosed on every receipt, no hidden spread.
For most workers, the Shor account is credited in the contract currency, typically within a couple of minutes. For employees on employment contracts in countries that use bank-direct pay, the funds are deposited straight to the worker's linked bank account at this step instead, with no Shor balance involved.
For workers whose pay lands in their Shor account: separately, on their own schedule, they initiate a withdrawal to an external bank account they've linked. This step uses the destination country's local banking rail: ACH, SEPA, UPI, FPS, PIX, etc. Workers on bank-direct pay contracts skip this step.
Employer-to-worker credits typically land in a couple of minutes. Workers on the wallet model can hold balances in multiple currencies and withdraw on their own schedule. Workers on bank-direct pay contracts receive funds straight to their bank at the same speed.
## Shor Accounts
Every user on Shor (employer or worker) has a **Shor account** with multi-currency balances.
**For employers**: a dedicated account that holds funds between the bank debit and the worker payout. Gives you clean float separation between operating cash and payroll cash, real-time visibility, and a single source of truth for reconciliation. Managed from **Finance → Accounts**.
**For workers**: a per-currency balance where their earnings land within minutes. Workers can hold the balance, withdraw to their own bank, or receive payments from multiple employers in different currencies without forced conversion. Managed from **Finance → Accounts** on their side.
## Payment Rails
Shor is a fintech platform, not a reseller of other payment services. We operate on the banking rails directly at two touchpoints:
* **Employer funding**: debiting the employer's bank account into their Shor account
* **Worker withdrawals**: moving the worker's Shor balance to their own bank account
In every supported country, Shor uses the local low-cost rail:
* **ACH** in the United States
* **SEPA** (and SEPA Instant where available) in the Eurozone
* **FPS** in the United Kingdom
* **UPI / IMPS / NEFT** in India
* **PIX** in Brazil
* **Interac** in Canada
* And equivalent rails in every other country Shor operates in
The rail is chosen automatically based on the country. You don't configure it; Shor just picks the best path.
## FX and Currency Conversion
Every contract specifies the currency the worker is paid in. Shor credits the worker's Shor account in that currency, with no conversion at credit time. **FX is charged only when a conversion actually happens.** There are two possible conversion points:
If the employer needs to pay in a currency their Shor account doesn't hold, Shor converts from their funding currency at a disclosed rate before approval. The employer sees the rate in the payroll run.
If the worker withdraws from a currency balance into a bank in a different currency, Shor converts at that moment at a disclosed rate. Same-currency withdrawals involve no FX. A small flat fee may apply depending on the destination rail, shown before the worker confirms.
When a conversion does happen:
1. Shor shows the rate before the action (approval for employers, withdrawal for workers)
2. The margin above the interbank rate is a flat 2%, disclosed and constant, not dynamically widened
3. The full breakdown (gross amount, FX rate, margin, net) appears on every receipt
If the worker's bank is in the same currency as their Shor balance, the withdrawal has **no FX at all**. Same-currency flows are common when the worker holds in their local currency or when the contract is denominated in their local currency.
## Timing
Two separate timings to think about:
**Employer → worker (payment):** typically a couple of minutes.
**Worker → bank (withdrawal):** depends on the worker's country rail.
| Rail | Typical settlement |
| - | - |
| Instant local rails (UPI, FPS, PIX, SEPA Instant, etc.) | Seconds to minutes |
| Standard local bank transfer | Same day to 1–2 business days |
| ACH (US) | 1–3 business days |
Shor shows the estimated arrival date before each withdrawal, so there are no surprises.
**Employer funding (bank → Shor account)** also follows the source country's rail: typically up to 5 business days for ACH, or same day to next business day if you send a wire directly to your Shor virtual account. Wire details (routing number, account number, bank info) are available under Finance → Accounts → Add Money. Employers can use auto-funding to debit ahead of payday so funds are in place on time.
## What Happens If Something Fails
Every payment is tracked with retries, idempotency, and monitoring:
* **Transient failures** (e.g., banking system temporarily down) are retried automatically
* **Hard failures** (e.g., wrong account number) pause the payment and notify both sides
* **Idempotency** guarantees you won't accidentally pay the same thing twice, even if a retry happens
Paused payments show up in the dashboard with the reason and a clear next step, usually "update bank details and retry."
## Reconciliation
For the employer, the Finance tab gives a clean double-entry view:
* Every debit from the connected bank has a matching credit into the employer's Shor account
* Every debit from the employer's Shor account has a matching credit into a worker's Shor account
* FX legs are recorded as their own transactions
Match against your own bank statement line-by-line at month-end, or export the full transaction log and import into your accounting software. Worker-side withdrawals from their Shor account to their own bank are recorded on the worker's ledger, not the employer's, because once paid, the funds are the worker's.
## Next Steps
How Shor keeps your money safe.
Why verification matters for money movement.
# Platform Overview
Source: https://docs.shorpay.com/platform/overview
A plain-English explanation of how Shor works under the hood.
Shor is built to make hiring and paying global teams simple, but there's real infrastructure behind the simplicity. This page walks through the moving parts so you understand what happens when you click **Send payment**.
## The Two Sides
Shor has two user types sharing one platform:
Companies that hire and pay workers. They manage contracts, fund payments, run payroll, and handle compliance.
The workers getting paid: contractors, employees, freelancers. They sign contracts, verify identity, and receive pay.
Both sides use the same core platform, with portals tailored to what each needs.
## What Shor Does
At a high level, Shor does five things:
We verify every company (KYB) and every worker (KYC) before they can send or receive money. This keeps the platform compliant and safe.
Every contract is generated from templates tailored to the worker's country and engagement type. Labor law rules are baked in.
Shor holds virtual accounts on behalf of each employer, debits connected bank accounts, handles currency conversion, and routes payments to workers via their preferred method.
The right tax forms are collected at onboarding, statutory withholdings are applied for EOR employees, and clean records are kept for audit.
Every movement (contracts, payments, transactions, tax forms) is stored with a clean audit trail and can be exported for accounting.
## The Layers
Behind the UI, Shor is built as three layers:
Templates, country rules, KYC/KYB, tax forms, labor law. This is where "compliant hiring" becomes real.
Virtual accounts, bank connections, FX, payment routing, reconciliation. This is where money actually moves.
Users, roles, contracts, payroll runs, transactions, documents. This is what you see and interact with in the app.
## A Typical Payment
To make the flow concrete, here's what happens when an employer approves a \$5,000 monthly fixed-rate payment to a contractor in India:
The employer approves the payroll run in the dashboard. The payment moves from **Pending** to **Approved**.
Shor debits \$5,000 from the employer's connected US bank account into their Shor account (1–3 business days on ACH, or the evening before on auto-fund).
Shor converts USD to INR at the rate shown and disclosed before approval.
The ₹-equivalent balance is credited to the contractor's Shor account, typically within a couple of minutes. Both sides get an email and see the payment as completed.
On their own schedule, the contractor withdraws from their Shor account to their own Indian bank via UPI or IMPS, typically in minutes. One pay cycle, two pay cycles, whenever they want.
Every leg (debit from employer's bank, the employer→worker credit, FX, and the eventual withdrawal) is recorded as linked transactions. Month-end reconciliation lines up cleanly on both sides.
## Next Steps
Where Shor supports hiring and payments.
A deeper look at how funds flow.
How Shor keeps your data and money safe.
What personal data Shor collects and how it's protected.
# Security
Source: https://docs.shorpay.com/platform/security
How Shor keeps your data and money safe.
Shor handles payroll data, identity documents, and money movement, all of which make us an attractive target if we're careless. Security is designed in, not bolted on. This page covers how we keep your data and funds safe.
## Data Security
Every connection to Shor is encrypted with TLS 1.2 or higher. No data moves between your browser or bank and our servers in the clear.
All stored data (contracts, identity documents, bank details) is encrypted at rest using industry-standard AES-256 encryption.
Sensitive values (API keys, signing secrets, database credentials) are held in a secrets manager with access tightly controlled and every access audited.
Your data is isolated from every other customer. Queries, authentication, and access checks are scoped by your business, and cross-tenant reads are not possible.
## Identity and Access
* **Modern auth**: sign in with email and password or via the sign-in options configured for your workspace
* **Role-based access**: admins, members, and viewers each have different permissions
* **Activity tracking**: significant actions (payroll approvals, funding changes, user invites) are recorded in our systems, with review available on request
* **Session controls**: idle session timeouts and the ability to sign out from your account settings
## Infrastructure Security
* Hosted on modern cloud infrastructure with hardened defaults (private networking, managed secrets, automated patching)
* Production environments isolated from development and staging
* Changes to production require code review and pass automated security checks
* Security reviews on a regular cadence as we scale
Formal compliance certifications (SOC 2, ISO 27001) and third-party penetration testing are on our roadmap as we grow. If your procurement process needs specifics today, reach out to [security@shorpay.com](mailto:security@shorpay.com). We're happy to share our current security posture in detail.
## Payment Security
Money movement has additional layers:
Only Admins can fund the account, run payments, or change billing. Members can do the day-to-day work of hiring and paying people but can't touch money controls. Viewers can see everything but can't take any action at all.
Every payment request carries an idempotency key. You can't accidentally pay someone twice, even if a browser retry happens.
Unusual activity (a sudden increase in volume, a payment to a new country, a change in funding source) triggers alerts for review.
Failed payments don't silently retry to a potentially wrong account. They pause and surface for your review with the specific error.
## Regulatory Posture
Shor operates within the regulations of the countries we serve:
* **Money transmission licensing** where required by jurisdiction
* **KYB** for every business on the platform
* **KYC** for every worker receiving payments
* **AML / sanctions screening** on every payment before it goes out
* **Data residency** options for customers in regions that require it
## Incident Response
If we detect a security issue, we act fast:
* Immediate containment (isolating affected systems)
* Customer notification if your data is involved
* Post-incident review, published to affected customers
* Preventive changes to ensure it doesn't recur
You can report a suspected security issue to [security@shorpay.com](mailto:security@shorpay.com).
## What You Can Do
Security is a shared responsibility. Some things you can do to strengthen your own account:
* **Use a strong unique password** with a password manager
* **Give admins the minimum access they need**: don't make everyone an Admin
* **Verify changes to bank details** out-of-band before approving them (fraud attempts often target bank account updates)
* **Review your team list quarterly** and remove access for anyone who's moved on
## Next Steps
What personal data Shor collects and how it's handled.
How identity verification works on Shor.
# Tax Compliance
Source: https://docs.shorpay.com/platform/tax-compliance
How tax forms, withholding, and reporting work on Shor.
Tax is one of the messiest parts of global payroll, and one of the places most likely to go wrong if you try to handle it manually. Shor handles the routine cases automatically and keeps clean records for the ones that need human judgment.
## What Shor Does Today
At onboarding, Shor collects the right US tax form from each worker: W-9 (US persons), W-8BEN (foreign individuals), or W-8BEN-E (foreign entities). Stored on the worker's profile and accessible to the employer.
For full EOR employment (where Shor employs the worker on your behalf), Shor applies the correct income tax and statutory contribution withholdings per the worker's country.
Every payment, contract, and tax form is stored with a clean audit trail. Exports are formatted for handoff to your accountant or tax software.
Every payment is screened against sanctions lists before it goes out, and unusual patterns trigger review.
## US Tax Forms Explained
If your business is US-based or you're paying US workers, tax forms matter. Shor handles the common cases:
For US persons (citizens, resident aliens, and US-registered entities). Required from any contractor before a US business can file a 1099 for them at year-end.
For foreign individuals working for US businesses. Certifies their foreign status and claims any tax treaty benefits (e.g., reduced withholding rates).
For foreign entities (non-US companies). Similar to W-8BEN but covers business entities rather than individuals.
Shor picks the right form based on the worker's tax residency and entity type, so you don't need to know which one applies.
## 1099 Reporting
For US employers paying US contractors, Shor handles year-end 1099 reporting end-to-end:
* Shor generates a **1099-NEC** for each US contractor whose calendar-year earnings cross the IRS reporting threshold
* Forms are filed with the IRS and delivered to each contractor in January or February for the prior tax year
* Both the employer and the contractor can access signed copies from their dashboard
The data needed (each contractor's W-9, the employer's info, and annual payment totals) is already on Shor, so there's nothing extra to pull together at year-end.
## Statutory Withholdings (EOR Employees)
For workers hired through Shor's full EOR product, Shor:
* Withholds income tax from each paycheck per the worker's country
* Remits employer contributions (pension, social security, health insurance) as required
* Files required tax returns with local authorities
The worker sees gross, deductions, and net on every pay stub. The employer sees total employer cost (salary + contributions + fees) before approving any payroll.
## Contractor Taxes
For independent contractors, Shor does NOT withhold tax. Contractors are responsible for their own tax filings in their country of residence. Shor helps by:
* Collecting the right US forms at onboarding (so US employers don't have to chase)
* Keeping clean payment records by company for easy tax filing
* Providing export files your accountant or tax software can use
* Issuing invoices and receipts with all the detail a tax authority would need
## Non-US Tax Filings
Shor doesn't currently file taxes in non-US jurisdictions for contractors. Workers are responsible for their own filings. But Shor makes this easier:
* Every payment has a clean receipt with amount, date, company, and reference
* Transaction exports by date range and by company
* Tax residency and identifying info stored on the worker's profile
Hand the export to a local accountant. Most are happy working from Shor's format.
## Compliance Updates
Tax rules change: thresholds shift, new forms are introduced, treaty benefits get updated. Shor monitors the changes and updates the platform. You don't need to track IRS or HMRC announcements yourself.
## What's Out of Scope (Today)
To be transparent about what Shor does NOT yet handle:
* Worker-country income tax filings for contractors
* Year-end tax form generation for countries other than the US
* Sales tax / VAT on invoiced services
* Personal tax advisory: Shor is not a tax advisor and won't tell you how to file your personal or business return
If any of these matter to your workflow, talk to your accountant or reach out to us about what's on the roadmap.
## Next Steps
How tax data is protected.
Where Shor supports workers and businesses today.
# Pricing
Source: https://docs.shorpay.com/pricing
Global payroll built on local rails. Transparent prices. No lock-ins.
Straightforward per-worker pricing. No setup fees, no per-payment surcharges, no annual contracts, no hidden FX markups.
## Plans
**\$19** / contractor / month
Global contractor management. Contracts, onboarding, invoicing, and payments in 100+ local currencies.
**\$299** / employee / month
Full employment across Asia, Latin America, Africa, and the Middle East.
**\$449** / employee / month
Full employment across Europe, North America, and Asia-Pacific.
Prices in USD. Contractor coverage is global, excluding OFAC-sanctioned jurisdictions (Cuba, Iran, North Korea, Syria, Belarus, and specific regions of Russia and Ukraine).
## How Shor Compares
| | **Shor** | Deel | Remote | Papaya |
| - | - | - | - | - |
| **EOR Standard markets** | **\$299 / mo** | \$599 / mo | \$599 / mo | \$599 / mo |
| **EOR Premium markets** | **\$449 / mo** | \$599 / mo | \$599 / mo | \$599 / mo |
| **Contractor** | **\$19 / mo** | \$49 / mo | \$29 / mo | \$30 / mo |
| **Payroll on your own entity** | **\$50–\$60 / mo** | Not published | Not published | Not published |
| **Region-based pricing** | **Yes** | No | No | No |
| **Annual lock-in** | **None** | Required | Required | Required |
| **Setup fees** | **None** | Varies | Varies | Varies |
Region-based pricing reflects the real cost of operating in each market, so you pay accurately for where your team is.
## EOR Country Coverage
### Standard Markets: \$299 / Employee / Month
| Asia | Latin America | Africa | Middle East |
| - | - | - | - |
| India | Argentina | Ghana | United Arab Emirates |
| Indonesia | Brazil | Kenya | |
| Nepal | Chile | Nigeria | |
| Pakistan | Colombia | Rwanda | |
| Philippines | Guatemala | South Africa | |
| | Mexico | Uganda | |
| | Peru | | |
### Premium Markets: \$449 / Employee / Month
| Europe | North America | Asia-Pacific |
| - | - | - |
| Finland | Canada | Singapore |
| Germany | | |
| Italy | | |
| Netherlands | | |
| Switzerland | | |
| United Kingdom | | |
See [Global Coverage](/platform/global-coverage) for the full country directory. More markets coming each quarter. Email us if yours isn't live yet.
## Bring Your Own Entity
Already have a local entity? Keep it. You stay the legal employer and we run gross-to-net payroll, statutory filings, and tax remittance on top of it, in the same dashboard as the rest of your team.
Managed payroll is priced per employee per month, and is far cheaper than EOR because you already carry the entity:
| | **Your entity** | Shor EOR |
| - | - | - |
| **Tier A markets** | **\$60 / mo** | \$299–\$449 / mo |
| **Tier B markets** | **\$50 / mo** | \$299 / mo |
### Tier A Markets: \$60 / Employee / Month
| Asia | Latin America | North America | Europe | Middle East |
| - | - | - | - | - |
| India | Brazil | Canada | Germany | United Arab Emirates |
| | Mexico | | United Kingdom | |
### Tier B Markets: \$50 / Employee / Month
| Asia | Latin America | Africa |
| - | - | - |
| Pakistan | Chile | Ghana |
| Philippines | Colombia | Kenya |
| | | Nigeria |
| | | South Africa |
Managed payroll is available in the 15 markets listed above. It requires that we can run the full payroll lifecycle locally, so it lags our EOR coverage. If your country isn't listed, [book a call](https://shor.cal.com/shor/shor-intro-call) and we'll tell you where it sits on the roadmap.
See [Payroll on Your Own Entity](/employer/managed-payroll) for how to register your entity and hire onto it. One difference worth knowing up front: because your entity is the legal employer, you supply the employment agreement rather than Shor generating one.
## What's Included
Every plan includes:
* Unlimited users on your company account
* Compliant employment or contractor agreements in every supported country
* KYC for workers and KYB for your business
* Multi-currency payments through local banking rails
* Automated tax engine (gross-to-net per country)
* US tax form collection (W-9, W-8BEN, W-8BEN-E) and year-end 1099 filing
* A professional portal for every worker
* Email and Slack support
## What You Won't Pay For
We show you the FX rate before any cross-currency payment. The margin is a flat 2% above the interbank rate, disclosed on every receipt, no buried spread.
Shor doesn't charge per payment, per invoice, or per tax form generated. Seat-based pricing means your monthly cost is predictable regardless of payment volume.
Creating your account, running KYB, inviting your team, and adding workers is free. You only start paying once you have an active worker on a signed contract.
Month-to-month billing. 30-day cancellation. Offboard workers or close your account anytime.
No minimum seat counts. Pay for exactly the workers you have.
## FAQ
**Contractor management** is for independent contractors you've already hired. We handle the contract, onboarding, and payments. They remain self-employed.
**EOR (Employer of Record)** is for full-time employees. We legally employ the person on your behalf and handle statutory compliance, income tax withholding, and benefits.
Use contractor for short-term, project-based, or flexible hires. Use EOR for full-time employees.
If you already own an entity in the country, there's a third option: keep the entity, stay the legal employer, and have us run the payroll. See [Bring Your Own Entity](#bring-your-own-entity).
Contractor onboarding is typically same-day. EOR onboarding takes 7-14 business days depending on country, driven by local statutory registration requirements.
Yes, fully, in every country we support. For US contractors, we collect W-9 / W-8BEN / W-8BEN-E forms at signing and file year-end 1099s on the employer's behalf.
No lock-ins, no cancellation fees, no annual contracts. For EOR, employee termination follows local labor law (statutory notice and severance vary by country).
Yes, and it's the cheapest way to hire with us: \$50–\$60 per employee per month depending on the country, versus \$299–\$449 for EOR.
You keep the entity and stay the legal employer. We run gross-to-net payroll, statutory filings, and tax remittance on top of it. See [Bring Your Own Entity](#bring-your-own-entity) for the country list, or [Payroll on Your Own Entity](/employer/managed-payroll) for how it works day to day.
For contractors, we support payment in almost every country globally. For EOR, our country roadmap is driven by where our customers actually hire. If you need a country that isn't live yet, email [sales@shorpay.com](mailto:sales@shorpay.com) or [book a call](https://shor.cal.com/shor/shor-intro-call). We can often fast-track a market for a committed customer.
## Ready to Start?
30 minutes with our team. See the product and get a custom quote.
For volume deals, unlisted countries, or custom plans.
# Working With Multiple Companies
Source: https://docs.shorpay.com/professional/companies
Manage contracts and payments from several clients in one Shor account.
If you work with more than one company (as an independent contractor, fractional operator, or freelancer) Shor's built to handle that cleanly. You don't need a separate account per company.
## The Companies Tab
Under **Contracts → Companies**, you'll see every company you have (or have had) a contract with. Each company card shows:
* Company name and logo
* Your active contract(s) with them
* Your payment history
* Quick actions: open dashboard, message the company, view contract
Click a company to focus your view on just their contracts, payments, and documents.
## One Profile, Many Companies
You only need to verify your identity once. Every company you work with uses the same verified profile; they see only the information relevant to your engagement with them.
What each company sees:
* Your name, role, and country
* The contract you have with them
* Payments they've sent you
* Any documents tied to the engagement
What each company does NOT see:
* Your other contracts
* Other companies you work with
* Your identity documents
* Payments from other companies
## Multi-Currency Balances, One Account
All payments from every company land in **one Shor account**, but the account holds a balance per currency. If one client pays in USD and another pays in EUR, you'll see a USD balance and a EUR balance, both in **Finance → Accounts**. Nothing is force-converted.
When you're ready to move funds out, link a bank account in **Finance → Connections** and withdraw from the currency balance you want. You can link multiple banks and pick a different destination per withdrawal, useful for splitting between savings and spending accounts.
## Invoicing and Records Per Company
The **Payments** and **Transactions** tabs can be filtered by company. You can:
* Export only payments from a single company for that company's records
* Pull a full year of earnings by company for tax filing
* Generate invoices per company for your own accounting
## Tax Forms Per Company
If you're a US contractor receiving 1099s, Shor keeps each company's W-9 and year-end 1099 separate: clean, per-employer records you can hand to your tax advisor without any manual reconciliation.
## Offboarding From One Company
When one contract ends, it doesn't affect your other engagements. You continue getting paid by your other companies exactly as before. The completed contract and its payment history stay in your archive.
## Next Steps
Managing your active and past contracts.
Tracking earnings across every company.
# Your Contracts
Source: https://docs.shorpay.com/professional/contracts
Review, manage, and keep track of every contract.
Every engagement you have through Shor is backed by a contract. The **Contracts** tab is where you see and manage all of them.
## What You'll See
For each contract:
* **Company**: who you're working with
* **Role**: your title on the engagement
* **Type**: employee, contractor (fixed, milestone, or pay-as-you-go)
* **Status**: pending signature, signed, active, offboarding, completed, or cancelled. An unsent draft stays with your employer until they send the contract
* **Compensation**: how and how much you're paid
* **Start date**: when the engagement began (or begins). For an EOR employment, this date follows the EOR agreement. If it changes before the contract is active, Shor updates it and emails you
* **End date**: if fixed term, when it ends
Click a contract to see the full document, payment history, and any pending action items.
## Contract Statuses
| Status | What it means |
| - | - |
| **Draft** | Held by your employer until they send the contract. It then appears in your list |
| **Pending signature** | Sent for signature. For contractor engagements, it's often already your turn; you and your employer can sign in either order. For employee contracts, you may still be waiting on your employer to sign first |
| **Signed** | Both sides have signed; the engagement starts on the agreed date |
| **Active** | You're actively engaged and can be paid |
| **Offboarding** | The engagement is ending; wrap-up is in progress |
| **Completed** | The engagement ended cleanly |
| **Cancelled** | The contract was voided before it became active |
## What to Check Before Signing
Make sure the job title, responsibilities, and deliverables match what you discussed. If anything's off, raise it with your employer before signing.
Check the rate, currency, pay frequency, and any milestones or variable pay. Make sure it matches your agreement.
Confirm the dates. If you're a contractor, check whether the contract has a fixed end date or rolls indefinitely.
Understand how much notice either side must give to end the engagement. For employees, this is usually dictated by local law.
Standard in most contracts, but read the specific wording. If you have existing IP you want to carve out, raise it before signing.
Some contracts include clauses that limit who else you can work for, during or after the engagement. These vary in enforceability by country, so know what you're agreeing to.
## Asking for Changes
If something in the contract needs to change, don't just decline. Message your employer from the contract page. Shor logs the conversation and links it to the contract.
Once they update the contract, you'll get a new version to review and sign.
## Amendments
For contractor engagements, changes to a live contract (rate updates, scope updates, extensions) are made as **amendments**. You'll get a notification when an amendment is proposed. Review it the same way you reviewed the original contract, and sign if you agree. If you're an employee, your employer updates your terms directly rather than through a contract amendment.
If the original agreement is your employer's own uploaded contract, you'll accept the change in Shor. You'll see **Acceptance Required**. Review the new terms, open any attached amendment PDF, and click **Accept changes**. Accepting replaces the current terms with the ones shown. Shor cannot assess whether those changes fit the legal terms of that agreement.
Every version of the contract and its amendments is kept, so you always have a clean history.
## Offboarding
When an engagement ends (either because you're moving on or the scope is complete) the contract moves into **Offboarding**. You'll get a summary of:
* Your final pay and any owed reimbursements
* Notice period and the official end date
* Documents you need to download while you still have access
Once you confirm, the contract moves to **Completed** and your access to that company's workspace is gracefully closed.
## Next Steps
Step-by-step walkthrough of the signing flow.
How to manage engagements across several employers.
# Identity Verification (KYC)
Source: https://docs.shorpay.com/professional/identity-verification
Verify who you are so you can get paid through Shor.
Identity verification (sometimes called KYC, for "Know Your Customer") is a regulatory requirement for any platform that moves money. It keeps the system safe and makes sure payments go to the right person.
## How It Works
On the verification screen, click **Start Verification**. A secure verification session opens and walks you through everything in one sitting, usually about 2 minutes.
Inside the session you'll:
A passport, driver's license, or national ID. It must be current (not expired) and show your photo and date of birth.
A quick real-time photo to confirm the ID matches the person on the account. This is a "liveness check": we need to see that it's really you, not a photo of a photo.
Review and confirm the name, date of birth, and address pulled from your ID. Add a phone number. Depending on your country, you may also be asked for a recent proof-of-address document.
Most verifications finish instantly. If anything needs manual review, it typically takes 1-2 business days; we'll email you when it's complete.
Tax forms (W-9, W-8BEN, W-8BEN-E) are **not** part of the identity verification session. They're collected separately during contract signing, when the specific form required depends on the engagement and your tax residency.
If you're an EOR employee, employee requirements stay locked until you submit identity verification. The contract shows **Verify your identity to unlock this step**. After you submit, you can save payroll details while verification is in review. Document uploads are requested after verification is approved. See [Signing a Contract](/professional/signing).
You can close the window mid-flow and come back later; your progress is saved. The button changes to **Continue Verification** until you finish.
## Tips for a Smooth Session
Take the photo in a well-lit room. Avoid glare on the ID; tilt slightly if needed to remove reflections.
Every edge of the ID should be visible in the frame. Cropped or cut-off images get rejected.
Don't upload a photo of your ID on another screen, or a photocopy. We need a photo of the physical document.
The name on your ID, on your profile, and on the contract should all match. If your legal name differs from what you go by, use your legal name on Shor.
## Verification Statuses
| Status | What it means |
| - | - |
| **Pending** | You haven't finished the session yet |
| **In review** | Submitted; typically takes 1-2 business days to complete |
| **Verified** | Approved; you can get paid |
| **Failed** | Something didn't pass; check your email for details and next steps |
## If Verification Fails
If your verification session is declined, you'll see this immediately: the onboarding screen shows what likely went wrong along with a **Try Again** button and a **Contact Support** button, so you don't have to wait on an email to take the next step. You'll also get an email explaining what happened. Common reasons:
* ID image was blurry or cropped
* ID was expired
* Selfie didn't match the ID
* Address or tax details didn't match your profile
Use **Try Again** to start a fresh verification session with a clear, well-lit photo. If you're stuck, use **Contact Support** or reach out directly. Manual review exists for exactly these cases.
## Privacy
Your identity documents are encrypted and stored only as long as needed for compliance. They're **not shared with your employer**; only the verification status is visible to them (so they know they can pay you).
## Next Steps
Review the contract, fill in tax forms, and sign.
Where pay lands, and how to withdraw to your bank.
How Shor handles your personal data.
# Milestones
Source: https://docs.shorpay.com/professional/milestones
Submit deliverables, track review, and get paid on approval.
If your contract is a **milestone** contract, your pay is tied to delivering specific outcomes. You submit each milestone when the work is done, your employer reviews it, and once approved, the payment credits to your Shor account.
## Where Milestones Live
Milestones are part of the contract itself, not a standalone tab. To see or submit one:
1. Go to **Contracts** on your dashboard
2. Open the contract in question
3. Scroll to the **Milestones** section
Each milestone shows its title, description, deliverable, amount, target date (if set), and current status.
## Milestone Statuses
| Status | What It Means |
| - | - |
| **Pending** | Defined in the contract but not yet started or submitted |
| **Submitted** | You've submitted the deliverable; awaiting employer review |
| **In Review** | Your employer is reviewing the submission |
| **Approved** | Employer accepted the deliverable; payment is queued |
| **Completed** | Milestone done; payment is being processed |
| **Paid** | Payment has landed in your Shor account |
| **Rejected** | Employer sent it back with feedback; you can revise and resubmit |
## Submitting a Milestone
From the contract page, find the milestone you want to submit and click into it.
Add anything that proves the work is done: files, links, notes, screenshots. Be specific so the employer can review quickly.
The milestone moves to **Submitted** and your employer gets a notification. You'll see the status change in real time.
## What Happens After Submission
Your employer reviews the deliverable and either:
* **Approves** it: the milestone moves to approved, the payment is queued, and credits to your Shor account once processed.
* **Rejects** it: the milestone comes back with a **rejection reason**. You can update the deliverable based on the feedback and resubmit without any penalty or delay.
You'll get an email either way.
## If a Milestone Is Rejected
Rejection isn't a failure; it's just "not done yet." The rejection note from your employer tells you what's missing. Revise the deliverable, replace the attachments, and click **Submit for Review** again. The status moves back to **Submitted** and review starts over.
## Getting Paid
Once the milestone is **Approved**, the payment follows the contract's payment terms. It shows up in:
* **Finance → Payments**: with status Processing then Completed
* **Finance → Accounts**: your balance goes up in the contract's currency
* **Finance → Transactions**: the full record of money movement
From there, you withdraw to your bank like any other payment. See [Your Shor Account & Withdrawals](/professional/payout-methods).
## Tips
The faster your employer can confirm "yes, this is done," the faster you get paid. Links to finished work, before/after screenshots, or a short summary of what changed all help.
If a milestone is defined as "Phase 1 complete with signoff from the team," don't submit when only you think it's done. Wait for the team's signoff; otherwise it bounces back.
If anything about the deliverable needs explanation (scope changes, dependencies, anything unusual) add it as a note when you submit. Saves a back-and-forth.
If the scope has shifted and the original milestone doesn't quite apply anymore, message your employer from the contract page. Adding or amending a milestone requires a contract amendment both sides sign.
## Next Steps
Manage active and past contracts.
How payments flow after approval.
# Creating Your Profile
Source: https://docs.shorpay.com/professional/onboarding
Set up your Shor account from invitation to ready-to-get-paid.
When a company invites you to Shor, onboarding is quick: three short screens and you're set up. If you were invited to a specific contract, you can see its terms right away, even before you verify your identity. Tax forms and contract signing happen after verification.
## Before You Start
Have ready:
* The invitation email from your employer (check spam if needed)
* A government-issued photo ID (passport, driver's license, or national ID)
* A phone or laptop with a camera for the selfie step
## The Flow
Click the link in your invitation email. It takes you to a signup page pre-filled with your name and email.
Set a password or continue with SSO. Verify your email.
On the role selection screen, choose **I'm a Professional**. You're here to get paid.
Tell us whether you're working as an **Individual** (freelancer or independent contractor) or through a **Business** entity (your own company or LLC). If it's a business, you'll add the business name, registered address, and country and state of incorporation.
Click **Start Verification** to open the secure verification session. Inside it, you'll upload your ID, take a selfie for a liveness check, and provide any other information required for your country. Most verifications finish instantly; if your submission enters manual review, it typically takes 1-2 business days.
Once verification completes, you're taken back to your pending contract to continue (or to your dashboard if you don't have one waiting).
## What Happens After Onboarding
From your dashboard, you'll see any contracts waiting for signature. Signing a contract will:
* Walk you through reviewing the agreement
* Collect the right US tax form if required (W-9, W-8BEN, or W-8BEN-E)
* Ask you to accept EOR terms if you're being hired as a full EOR employee
* Let you sign electronically, or collect the agreement in ink off this platform when local law requires it
Payments land in your Shor account within minutes of your employer approving them; no setup required for that. Separately, when you want to withdraw to your own bank, link it from **Finance → Connections**.
## Pausing and Resuming
If you need to step away mid-verification, just close the window. Your progress is saved; the button will say **Continue Verification** next time you come back.
## Next Steps
What the verification session looks like.
Review, fill in tax info, and sign.
Where pay lands, and how to withdraw to your bank.
# Professional Overview
Source: https://docs.shorpay.com/professional/overview
A tour of your Shor dashboard as a worker.
If you're getting paid through Shor, this is your guide to what you can do in your dashboard. You'll find everything you need to sign contracts, get paid, and manage your work across clients.
## Dashboard Sections
A snapshot of your active contracts, upcoming payments, recent activity, and anything that needs your attention.
Your active and past contracts, and the companies you work with.
Your payout accounts, payment history, and transaction ledger.
Your profile, tax documents, and personal preferences.
## What You Can Do
Review and sign contracts your employer sends you. Every contract respects the labor laws of your country.
Payments land in your Shor account within minutes. Withdraw to your own bank when you want, through your country's native banking rails.
See every payment, upcoming and past, across every company you work with.
US tax forms (W-9, W-8BEN, W-8BEN-E) are generated and stored for you when required.
## If You Work With Multiple Companies
Shor is built for contractors who work with multiple clients. A single Shor account can hold contracts with any number of companies, each with its own contract and pay schedule. All payments land in the same Shor account (with per-currency balances), and you withdraw to your own bank on your own schedule.
See [Working with multiple companies](/professional/companies) for the details.
## Your First Steps
Complete your profile and verify your identity.
Where pay lands, and how to withdraw to your bank.
# Requesting a Payment
Source: https://docs.shorpay.com/professional/payment-requests
Ask your employer for an ad-hoc payment and track it until it's approved or denied.
Not every payment comes from a salary schedule, timesheet, or milestone. When you need a bonus, reimbursement, or other one-off amount, you can request it directly from your employer. They review the request and either approve it (which starts payment right away) or deny it with a reason.
## When to Request a Payment
Use a payment request when the amount isn't already covered by your regular pay cycle:
* A bonus or discretionary payment
* A reimbursement for something you paid out of pocket
* Contractor, freelance, or consulting work outside your normal schedule
If the work is already defined as a [milestone](/professional/milestones) or billed through [timesheets](/professional/timesheets), submit those instead. Payment requests are for ad-hoc amounts your employer hasn't already set up.
## What You Need
You can only request payment from a business where you have an **active** (or offboarding) contract with a supported payment currency. If no payers show up in the wizard, you don't have an eligible contract yet.
## How to Request a Payment
Start from **Finance → Payments** and click **Request Payment**. The wizard has four steps:
Choose who you're requesting from. Shor lists each business you have an eligible contract with. The currency for the request comes from that contract and can't be changed.
Enter how much you're requesting. The amount must be greater than zero and is always in your contract's currency.
Pick a **purpose** (Reimbursement, Contractor Payment, Freelance Work, Consulting, or Bonus). Optionally add notes (up to 2,000 characters) and attach supporting documents.
Review the payer, amount, purpose, notes, and attachments, then click **Submit request**. Your employer must approve before payment begins.
## Attachments
Attachments are optional but helpful for reimbursements and anything that needs a receipt.
* Up to **10 files**
* **PDF, PNG, or JPG** only
* **10 MB** max per file
## After You Submit
Your request appears in **Finance → Payments** with status **Pending review**. Your employer gets a notification to review it.
| Status | What it means |
| - | - |
| **Pending review** | Waiting for your employer to approve or deny |
| **Approved** | Your employer approved it; the request becomes a normal payment and begins processing |
| **Denied** | Your employer declined it and left a reason you can read on the request |
| **Withdrawn** | You cancelled the request before they reviewed it |
| **Cancelled** | Shor cancelled it automatically (for example, the contract ended or its currency changed) |
Once approved, the row leaves the request list and shows up as a payment (labeled **Requested payment**). From there it follows the normal [payment lifecycle](/professional/payments#the-payment-lifecycle): processing, then completed in your Shor account.
You'll get an email when a request is approved, denied, or cancelled. Withdrawing a request yourself doesn't send a notification to your employer.
## Withdrawing a Request
Changed your mind? Open a **Pending review** request and click **Withdraw request**. Confirmed withdrawals can't be approved afterward. If you still need the payment, submit a new request.
You can only withdraw while the request is still pending. Approved, denied, cancelled, or already-withdrawn requests can't be withdrawn again.
## What Your Employer Sees
Your employer reviews requests in **Finance → Payments**. A business admin can **approve** (payment processing starts immediately with the amount and details you submitted) or **deny** with a reason. They can't edit your amount, purpose, notes, or attachments; it's approve as submitted or deny.
## Next Steps
How approved payments credit your Shor account and when you can withdraw.
Link a payout method and move money to your bank.
For deliverable-based pay with an approval flow.
Submit hourly or daily hours for approval.
# Getting Paid
Source: https://docs.shorpay.com/professional/payments
How payments flow from your Employer to your Shor account, and from there to your bank.
On Shor, "getting paid" happens in two stages:
1. **Employer approves a payment** → money credits to your **Shor account**. For most payment types this happens within a couple of minutes; hourly and daily pay instead follows your contract's settlement schedule (see below).
2. **You withdraw** from your Shor account to your own bank whenever you want.
The first step is fast. The second is on your schedule. This page covers both.
## The Payment Lifecycle
Every payment moves through a few states:
| Status | What it means |
| - | - |
| **Pending** | Your employer has queued the payment; not yet approved or funded |
| **Processing** | Approved and on its way to your Shor account or bank account |
| **Completed** | Credited to your Shor balance, or deposited to your linked bank account if your contract uses bank-direct pay |
| **Failed** | Something went wrong; check the details for the reason |
| **Cancelled** | Your employer cancelled the payment before it was sent |
Once a payment is **Completed**, the money is yours. For most workers it lands in your Shor balance and you withdraw on your own schedule. For employees on employment contracts that use bank-direct pay, it lands in your linked bank account instead, with no separate withdrawal step needed.
## When You Get Paid
This depends on the payment type:
Paid on the schedule in your contract (weekly, biweekly, or monthly; some Fixed Rate retainers pay daily, including weekends). You'll see the next pay date on your dashboard.
Paid after your employer approves your timesheet, on your contract's scheduled settlement date. If your contract has no payment delay, that can be the same day; otherwise it lands on the scheduled date. Check your dashboard for the exact date.
Paid when your employer approves the milestone. Submit the deliverable, wait for approval, and the payment is released to your Shor account.
Sent ad-hoc by your employer, or [requested by you](/professional/payment-requests) from **Finance → Payments** and approved by your employer. You'll get a notification either way once it's on its way.
## Tracking an Incoming Payment
When a payment is initiated:
* You'll get an email notification
* It appears in **Finance → Payments** with status **Processing**
* Once funded, it moves to **Completed** and your balance in **Finance → Accounts** goes up
There's no separate "bank arrival" wait for the payment itself; crediting to your Shor account happens as soon as the employer's funding clears.
## Multi-Currency Balances
Every payment credits your Shor account in the currency specified by your contract; that's what you receive. If you have multiple contracts in different currencies (say, one paying USD and one paying EUR), your Shor account holds a separate balance per currency, both visible in **Finance → Accounts**. Nothing is force-converted.
FX is charged only when a conversion actually happens. If you withdraw from a currency balance into a bank in the same currency, no FX. If you withdraw into a bank in a different currency, Shor shows the rate before you confirm.
## Withdrawing to Your Bank
Payments always land in your Shor account. Getting the money out to your own bank is a separate action. See [Your Shor account & withdrawals](/professional/payout-methods) for the full flow.
Withdrawal timing uses your country's local banking rail:
* **Instant rails** (UPI, FPS, PIX, SEPA Instant): seconds to minutes
* **Standard local transfers**: same day to 1–2 business days
* **ACH in the US**: typically 1–3 business days
The important distinction: the **payment** to your Shor account typically lands within minutes. The **withdrawal** to your bank follows the rail's normal timing. You control when that withdrawal happens.
## If a Payment Fails
Payment failures are rare, but possible reasons:
* Employer's funding was insufficient at the debit time
* Sanctions screening flagged the payment for review
* Your account is in a verification pending state
If a payment fails, you'll get an email with the reason. The employer can retry without re-entering details once the cause is fixed.
## Payslips and Invoices
Every payment comes with a receipt:
* **Employees** get a payslip showing gross, deductions, and net
* **Contractors** get an invoice-style receipt showing the payment and reference
* Both can be downloaded as PDFs from the payment detail page
* **Contractors** can also upload their own invoice PDF to use instead of the auto-generated one; the employer automatically sees whichever version you provide
* **Contractors paid in India through their Shor balance** additionally get a foreign inward remittance certificate (FIRC), downloadable from the payment detail page for each completed payment, and again from the transaction detail page when they withdraw that balance to an Indian bank account
## Next Steps
Ask your employer for a bonus, reimbursement, or other one-off amount.
How to link a payout method and withdraw your balance.
The full ledger of credits, withdrawals, and FX conversions.
US tax forms ready when you need them.
# Your Shor Account & Withdrawals
Source: https://docs.shorpay.com/professional/payout-methods
Money lands in your Shor account within minutes. You withdraw to your linked payout method when you need it.
When your employer pays you, the money lands in **your Shor account** within a few minutes. From there, you withdraw to your linked payout method whenever you want.
If you're on an employment contract in a country that uses bank-direct pay, your salary is deposited straight to your linked bank account instead. In that case you don't have a Shor balance to withdraw from, and this page's withdrawal flow doesn't apply to you. Your contract details show which model applies.
## Two Separate Flows
Your employer approves a payment → it's credited to your Shor balance within a couple of minutes. No waiting for bank rails to clear.
Separately, you link a payout method and withdraw from your Shor balance on your own schedule. The withdrawal uses the rail for your chosen method.
## Your Shor Account
Your account lives in **Finance → Accounts** and shows a balance per currency. If your employer pays in USD and you also do work for a company paying in EUR, you'll see separate USD and EUR balances.
You can:
* **Hold the balance** as long as you want; nothing forces a withdrawal
* **Withdraw part or all** to your linked payout method at any time
* **See every credit and withdrawal** in Finance → Transactions
## Linking a Payout Method
From your professional dashboard, open the Finance tab and click **Connections**.
A dialog opens. First select the country of your payout account, then choose the payment method available for that country (bank transfer, mobile money, SWIFT, ACH, local payout ID such as Pix or UPI, and others depending on your country). Finally, fill in the details for the chosen method.
Depending on your country and method, Shor may ask you to confirm ownership (for example, a small test deposit or a screenshot).
Your payout account is registered under your verified legal name on file with Shor, so make sure your profile name matches your ID before linking an account.
## Making a Withdrawal
Once a payout method is linked, go to **Finance → Accounts**, pick the balance you want to withdraw from, and click **Withdraw**. Choose the destination account, enter an amount, and confirm. Timing depends on the method and rail:
* Instant rails (UPI, FPS, PIX, SEPA Instant): seconds to minutes
* Standard local transfers: same day to 1–2 business days
* ACH in the US: 1–3 business days
Shor shows the estimated arrival date before you confirm each withdrawal.
## Auto Withdraw
If you'd rather not withdraw manually every time, you can turn on **Auto Withdraw** for one of your linked accounts from **Finance → Connections**. Once enabled, Shor automatically withdraws your full available balance, in every currency you hold, to that account shortly after each payment settles. Only one account can be your Auto Withdraw destination at a time, and you can turn it off anytime from Connections.
## Details You'll Need
What the form asks for depends on your country and the payment method you choose:
* **Bank transfer (United States)**: routing number and account number
* **Bank transfer (Europe)**: IBAN and BIC/SWIFT
* **Bank transfer (United Kingdom)**: sort code and account number, or IBAN
* **Bank transfer (India)**: IFSC code and account number
* **Mobile money**: phone number and mobile money provider
* **Local payout ID (Pix, UPI, etc.)**: the relevant ID or phone number for that rail
* **Other methods and countries**: Shor's form shows exactly which fields are required once you select your country and method
## Multiple Payout Methods
You can link more than one payout method. Pick which one to withdraw to when you initiate each withdrawal. Useful if you prefer different methods for different currencies or use cases.
## Fees and FX
* **Incoming payments to your Shor account**: no fee to you as the worker. The employer covers the pricing on their side.
* **You're paid in the contract currency**: each payment credits your Shor account in whatever currency your contract specifies (USD, EUR, INR, etc.). That's the only currency involved at credit time.
* **Multi-currency balances**: if you have multiple contracts in different currencies, you'll see a separate balance per currency in **Finance → Accounts**. Nothing is force-converted.
* **FX only when you actually convert**: FX is charged only when a conversion actually happens. Withdrawing from a currency balance into a bank in the same currency = no FX. Withdrawing into a bank in a different currency = FX at a disclosed rate, shown before you confirm. No hidden spread.
* **Withdrawal fees**: Shor uses the cheapest local rail available. A small flat fee may apply depending on the destination rail and currency, always disclosed before you confirm, no surprises. The listed fee for each method (for example "Fee 1.50 USD" or "No fee") appears when you pick a payment method and when you choose a withdrawal destination; the final fee for your amount is shown on the confirm step.
## What This Gives You
* **Fast visibility of earnings**: typically within minutes of your employer approving the payment, useful for cash-flow planning
* **Withdraw on your own schedule**: batch a few pay cycles, or pull daily
* **Multi-currency balances**: hold in USD, EUR, etc. without forced conversion
## Next Steps
What happens from the moment your employer approves a payment.
Every credit, withdrawal, and FX conversion in one place.
# Signing a Contract
Source: https://docs.shorpay.com/professional/signing
Review, complete tax info, and sign your contract on Shor.
When a company sends you a contract, signing is more than just hitting "agree." Depending on the engagement, you may need to submit a US tax form, accept EOR terms, or fill in extra employee information. Shor walks you through each step.
## The Signing Flow
Once your identity verification is complete, you can sign. If you're a contractor, you don't have to wait on your employer: whoever is ready first signs first, and the other side countersigns. If you're being hired as an employee, your employer reviews and signs first, then the contract comes to you.
If you're an EOR employee, employee requirements stay locked until you submit identity verification. The contract shows **Verify your identity to unlock this step**. After you submit, you can fill in and save payroll details while verification is pending or under review. These answers are saved as drafts; saving them does not accept or sign your contract. Supporting document uploads are requested after identity verification is approved. Return to the employee requirements form after approval to review your saved details and complete any remaining requirements.
You need to create your account and finish identity verification before you can sign. See [Identity Verification](/professional/identity-verification). This usually takes minutes, occasionally 1-2 business days if manual review is needed.
If you're a contractor, your signing invite arrives as soon as your verification is approved, whether or not your employer has signed yet. If you're being hired as an employee, your employer reviews and signs first, then you get an email with a link to sign.
Click the link in your invitation email, or find it in **Contracts** on your dashboard under **Pending signature**.
Scroll through the whole contract. Shor surfaces key fields (compensation, term, notice, jurisdiction), but read the full text, not just the summary.
If your engagement is with a US business, Shor collects the right US tax form: **W-9** (US persons), **W-8BEN** (foreign individuals), or **W-8BEN-E** (foreign entities). Fields pre-fill from your profile; you review and confirm.
If you're being hired as a full EOR employee, you'll also accept the EOR-specific terms that govern the employment relationship in your country.
Employees may be asked for additional details needed for onboarding: bank account, emergency contact, tax residency specifics, a supporting document upload, and anything else your country requires. Some of these details come from your employer instead of you. Submit identity verification before this step unlocks. After you submit, your dashboard's **Complete your employment details** step lets you fill these in while verification is in review. Documents are requested once verification is approved, and you can pick up saved answers afterward. After you submit the requirements, Shor verifies the information with your country's payroll system, which can take a few minutes; you won't be able to finish signing until that check completes.
When everything is complete, click **Sign**. In most countries, signing is electronic with a full audit trail (timestamp, IP address, and signing device). In a few countries, local law requires the employment agreement to be signed in ink, off this platform. Shor will tell you on the contract page, and our local partner collects the signed agreement from you. Once the signed copy is on file, the contract is fully executed and becomes active on the agreed start date. If the EOR agreement's start date changes before the contract is active, Shor updates that date and emails you.
## What to Check Before Signing
Make sure the job title, responsibilities, and deliverables match what you discussed. If anything's off, raise it before signing.
Check the rate, currency, pay frequency, and any milestones or variable pay. Make sure it matches your agreement. If you're an EOR employee, you'll also see an estimated net (take-home) pay figure alongside your gross salary before you accept.
Confirm the dates. If you're a contractor, check whether the contract has a fixed end date or rolls indefinitely.
Understand how much notice either side must give to end the engagement. For employees, this is dictated by local law.
Standard in most contracts, but read the specific wording. If you have existing IP you want to carve out, raise it before signing.
Some contracts include clauses limiting who else you can work for, during or after the engagement. These vary in enforceability by country, so know what you're agreeing to.
## Requesting Changes
If something in the contract isn't right, you have two options:
* **Request changes**: message your employer from the contract page. They can update the draft and resend a new version for you to review.
* **Decline**: if you don't want the engagement at all, you can decline. The contract is cancelled. You can always re-engage later with a new contract.
## After Signing
Once both sides sign:
* The contract moves to **Signed**, then **Active** on the start date
* A PDF copy is saved on your profile for your records
* Your employer can add you to payroll runs and payments
* The tax form you submitted is archived in **Settings → Tax Forms**
## Saving a Copy
Every signed contract is available as a PDF from **Contracts** on your dashboard. Download it for your records, especially if you'll need it for immigration, loan applications, or tax filing.
## Next Steps
How balances, linked banks, and withdrawals work.
Track what you've been paid.
Find the tax forms you've signed.
# Tax Documents
Source: https://docs.shorpay.com/professional/tax-documents
View and download the US tax forms you've signed through Shor.
The **Settings → Tax Forms** page shows every US tax form you've signed through Shor. It's a view-and-download archive; you can't submit new forms from here. Those are collected during contract signing.
Tax forms here refer specifically to US tax forms collected at contract signing. For tax filings in your own country, see [Transactions](/professional/transactions) to export your earnings for your accountant.
## Where Tax Forms Come From
When you sign a contract for work with a US-based business, the signing flow collects the right US tax form for your tax status:
For **US persons**: US citizens, resident aliens, and US-registered entities. Required so the right 1099 can be filed if your total earnings from a US employer cross the reporting threshold.
For **foreign individuals**: certifies your foreign status and any applicable tax treaty benefits.
For **foreign entities**: similar to W-8BEN but for business entities rather than individuals.
Shor picks the right form based on your tax residency and whether you're contracting as an individual or a business entity. The form fields pre-fill from your profile so you mainly review and confirm.
## Viewing and Downloading
From **Settings → Tax Forms**, you can:
* See every tax form you've signed
* Download a PDF copy of each form
* Check when the form was signed
Forms are stored securely and linked to the contract they belong to.
## When to Submit an Updated Form
Your circumstances can change. You might move countries, convert from an individual to a business entity, get a new tax ID, or become a US person. When that happens:
* For **active contracts** that use a form affected by the change: reach out to your employer or Shor support. The employer can re-initiate the tax form step on the affected contracts.
* For **new contracts**: the signing flow will collect a fresh form based on your current profile details.
If your tax status changes (for example, from foreign to US person after getting a green card), tell your employers as soon as possible. They may need to update how they report payments to you for the rest of the year.
## Year-End 1099s
If a US-based employer paid you over the IRS reporting threshold in a calendar year, you're entitled to a **1099-NEC**.
Shor generates and files the 1099 on your employer's behalf. Everything the form needs (your W-9, the employer's details, and the exact amount paid) is already on Shor, so the form is assembled, filed with the IRS, and delivered to you without you or your employer chasing paperwork at year-end.
You'll find the signed 1099 in **Settings → Tax Forms** in January or February for the prior tax year. A copy is emailed to you at the same time.
## Non-US Tax Filings
Shor doesn't currently generate tax forms for non-US jurisdictions. For your home-country tax return:
* Use the **Transactions** export (from **Finance → Transactions**) to pull your annual earnings by company
* Hand the export plus any country-specific documents from your employer to your tax advisor
Most advisors are happy working from Shor's export format.
## Privacy
Your tax forms are shared only with the specific employer they relate to, never with other companies you've worked with on Shor. Each company sees only the form attached to their contract with you.
## Next Steps
Export your earnings for tax filing.
How tax forms are collected when you sign.
How Shor protects your personal data.
# Timesheets
Source: https://docs.shorpay.com/professional/timesheets
Submit hours for Pay-As-You-Go contracts and get paid per approved cycle.
If your contract is **Pay-As-You-Go (PAYG)**, you submit your hours each pay period. Your employer approves, and approved hours flow into your next payment.
## Where Timesheets Live
Timesheets live inside each PAYG contract, not as a standalone tab. To submit time:
1. Go to **Contracts** on your dashboard
2. Open the PAYG contract
3. Find the **Timesheet** section
You'll see the current pay period (e.g., "Apr 1 – Apr 30"), your rate, and any past timesheets.
## Timesheet Statuses
| Status | What It Means |
| - | - |
| **Submitted** | You've submitted hours; awaiting employer review |
| **Approved** | Employer accepted the hours; they roll into the next payment |
| **Rejected** | Employer sent it back with feedback; you can revise and resubmit |
## Submitting Hours
The active pay period is at the top of the Timesheet section. It shows the start and end dates.
Fill in the number of hours for the period. The dialog shows a live total based on your rate × hours.
Use the notes field to add context: specific tasks, unusual deliverables, anything your employer needs to review against.
Submit the timesheet. Your employer gets a notification and the status moves to **Submitted**.
## What Happens After Submission
Your employer reviews and either:
* **Approves** the timesheet: the approved units flow into your next scheduled payment. The payment shows up on the Payroll side of your account and credits to your Shor balance once processed.
* **Rejects** the timesheet with a reason. You update and resubmit.
Either way, you get an email notification.
## Rate × Units = Payment
Each approved timesheet creates a line item of `rate × hours` in the contract's currency. If your contract is $50/hour and you submit 32 hours, the resulting payment is $1,600.
The exact amount is visible on the timesheet submission dialog before you confirm, so there are no surprises.
## Pay Period Timing
The pay period is set by the contract (weekly, biweekly, monthly). Submit your time before the end of the period, or as soon as you're done working, if your contract uses shorter cycles.
Approved hours typically pay out on the contract's next scheduled pay date. Check the contract's payment frequency for exact timing.
## Timesheet History
Past timesheets are listed in the same section, with status, units, total amount, submission date, and review date. Useful for:
* Confirming what was approved in past cycles
* Reconciling with your own records
* Resolving disputes ("what did I bill for last month?")
## If a Timesheet Is Rejected
Rejection usually means something didn't match your employer's records: wrong hours, missing detail, or a task outside the scope. The rejection note explains what's needed. Revise the timesheet entry (hours and notes) and resubmit.
## Tips
Submit as close to the period end as possible. Details are fresh, reviewers can approve faster, and you get paid on time.
"32 hours on the X project, including client review meetings Mon/Wed/Fri" is much faster to approve than just "32 hours." The more detail you give, the less back-and-forth.
Track your own time outside Shor (in a spreadsheet, notes app, whatever). Submitting a timesheet you can't back up with your own records is risky if a dispute comes up.
If your contract has different rates for overtime or weekends, submit them per the contract's rules. Ask your employer if you're unsure; it's easier to clarify upfront than after a rejection.
## Next Steps
See your PAYG and other contracts.
How approved hours flow into payments.
# Transactions
Source: https://docs.shorpay.com/professional/transactions
Your full ledger of incoming payments and withdrawals.
The **Transactions** tab is your complete record of every payment into your Shor account and every withdrawal out of it, across every company and every currency.
## What You'll See
Every transaction has:
* **Date**: when it completed
* **Company**: which employer sent it (for payments)
* **Amount and currency**: both the sent amount and what you received
* **Type**: salary, hourly, milestone, reimbursement, bonus, commission, or withdrawal
* **Status**: pending, processing, completed, failed
* **Reference**: any note your employer added
Click any transaction to see the full detail, including the source payment or, for a withdrawal, the FX rate (if any conversion happened) and a downloadable receipt. Contractors paid in India through their Shor balance also get a foreign inward remittance certificate (FIRC) on a completed withdrawal to an Indian bank account.
## Filtering and Searching
Use filters to narrow the list:
* **Date range**: e.g., "last month", "year to date"
* **Company**: focus on one employer
* **Type**: e.g., only milestone payments
* **Status**: e.g., only failed or only completed
* **Currency**: e.g., only EUR-denominated payments
## Exporting for Tax Filing
At tax time, you'll want a clean export of the year's earnings by company. From Transactions, click **Export** and pick your date range. The CSV includes:
* Every completed payment
* The sending company
* The gross amount, FX rate, and net received
* The reference or description
* The transaction status
Give this to your accountant, or import it directly into your tax software.
## Currency Totals
The Transactions view shows a running total by currency. If you're paid in multiple currencies (e.g., USD from one client and EUR from another), you'll see:
* Total received this period per currency
* Year-to-date total per currency
These are totals of what actually landed in your accounts, not what the employer sent before fees or FX. Perfect for accounting.
## Reconciling Against Your Bank
To match Shor transactions against your own bank statement:
1. Filter to **Completed** transactions for the statement period
2. For each transaction, the receipt shows the exact amount and reference that will appear on your bank statement
3. Tick them off against your bank statement line by line
If anything doesn't reconcile, the transaction receipt includes a detailed timeline. You can see exactly when each step (initiated, in flight, completed) happened.
## Next Steps
US tax forms for contractors and foreign workers.
Link a bank and withdraw your balance when you want.
# Quick Start for Employers
Source: https://docs.shorpay.com/quickstart/employer
Set up your company and run your first payment in under an hour.
This guide walks you through creating your Shor account, verifying your business, adding your first worker, and sending your first payment.
## Before You Start
Have ready:
* Your company's legal name, registration number, and registered address
* Incorporation documents and a recent proof of address
* A valid ID for the person signing up
* Ownership details for anyone owning 25%+ of the company
* A business bank account you can connect to fund payments
* The name and email of the first worker you want to pay (for employees you'll also pick the country of employment)
## Step 1: Create Your Account
1. Go to [app.shorpay.com/signup](https://app.shorpay.com/signup). Sign-up is self-serve — no call required.
2. Enter your work email and create a password, or sign in with SSO.
3. When prompted, choose **I'm an Employer**.
## Step 2: Verify Your Business
Shor runs a single, guided verification session:
1. Click **Start Verification**.
2. In the secure frame, fill in your company details, upload incorporation and proof-of-address documents, disclose beneficial owners, and verify your own identity.
3. Once submitted, Shor's compliance team reviews the case on top of the automated checks. Straightforward submissions are typically approved within one business day; you'll get an email when the review is complete or if anything needs clarification.
You can close the window and come back; your progress is saved. The button turns into **Continue Verification** until you finish.
See the full [Company onboarding & verification](/employer/onboarding) guide for document tips and common rejection reasons.
## Step 3: Connect Funding
Once verified, head to **Finance → Connections** and click **Connect Bank Account**. Shor uses the connected bank to fund payments you approve. You can also enable **automatic funding** later (Settings → Payments) so the bank account is debited the evening before payments are due.
## Step 4: Add Your First Worker
From **Talent → People**, click **Add person**. A contract wizard walks you through four steps:
1. **Start**: pick or invite the professional by email, choose Contractor or Employee, and the contract type (Fixed Rate, Milestone, or Pay-As-You-Go for contractors; Employee track for full EOR). For employees, you also pick the Country of Employment here.
2. **Agreement**: project name, department, and start date — plus the milestones (titles, deliverables, and amounts) for Milestone contracts. For employees, also job title, seniority, and employment terms.
3. **Compensation**: rate and currency, based on the contract type (hourly for Pay-As-You-Go, retainer for Fixed Rate, salary for employees; Milestone amounts are set in the Agreement step), plus pay frequency where applicable.
4. **Summary**: review everything, then send the contract for signature.
Your worker will receive an email inviting them to create their Shor profile, set their country and personal details, verify their identity, sign the contract, complete any required tax forms (W-9, W-8BEN, or W-8BEN-E), and add their payout details.
## Step 5: Send Your First Payment
For salaried employees and fixed-rate contractors, Shor auto-generates upcoming payments on their schedule. Open **Talent → Payroll**, select the rows you want to process, and confirm. The connected bank account is debited and each payment is released.
For a single bonus, reimbursement, or ad-hoc payment, go to **Finance → Payments** and click **Send payment**. Pick the recipient, amount, currency, and purpose, then review and confirm.
For milestone contracts, open the worker's contract, review the submitted milestone, and approve it. The milestone payment appears on the Payroll page ready to process.
## What Happens Next
* Payment status moves from **Pending** → **Processing** → **Completed**.
* The worker gets an email when their payment arrives.
* A receipt and reconciliation entry appear in **Transactions**.
* On the first of the month, Shor bills you for the active workers on your plan.
## Next Steps
Scale up your team with the same flow.
Process scheduled payments in batches.
Turn on auto-funding and auto-payments.
See what you're paying for and download invoices.
# Quick Start for Professionals
Source: https://docs.shorpay.com/quickstart/professional
Create your profile, sign your contract, and get paid.
If a company is hiring you through Shor, this guide gets you from invitation to first payment.
## Before You Start
Have ready:
* The invitation email from your employer (check spam if you haven't seen it)
* A government-issued photo ID (passport, driver's license, or national ID)
* A phone or laptop with a camera for the selfie
* Bank account details (optional at signup; added later from Finance → Connections for when you want to withdraw from your Shor balance)
## Step 1: Accept Your Invitation
Open the email from Shor and click **Accept invitation**. You'll land on a signup page pre-filled with your name and email.
Set a password or continue with SSO. Verify your email.
Shor asks whether you're here to get paid (professional) or hiring (employer). Choose **I'm a Professional**.
## Step 2: Pick How You're Contracting
Tell Shor whether you're working as an **Individual** (freelancer or independent contractor) or through a **Business** entity (your own company or LLC). If it's a business, you'll add the business name, registered address, and country and state of incorporation.
This choice affects your contract template and the tax form you'll fill in later.
## Step 3: Verify Your Identity
Click **Start Verification**. A secure verification session opens (usually about 2 minutes) and walks you through uploading your ID, taking a selfie, and providing any extra details needed for your country.
Most verifications finish instantly. If anything needs manual review, we'll email you as soon as it's complete.
Once verification is done, you're taken straight back to your contract if one's waiting for you (otherwise, to your dashboard). You can review your contract's terms as soon as you're invited, even before this step.
## Step 4: Sign Your Contract
If a contract is waiting for you, you're already on it. Otherwise, open it from your dashboard. The signing flow:
1. Lets you read the full contract and check the terms
2. Collects the right US tax form if needed (W-9 for US persons, W-8BEN for foreign individuals, W-8BEN-E for foreign entities)
3. Asks you to accept EOR terms if you're being hired as a full EOR employee
4. Has you sign electronically in most countries, or explains when local law requires signing in ink off this platform
If you're a contractor, you and your employer can sign in either order. If you're being hired as an employee, your employer signs first. Once both sides sign, the contract is active.
## Step 5: Link a Bank Account for Withdrawals
Payments arrive **in your Shor account within minutes** of your employer approving them. You don't need a bank account for that to happen.
What a bank account enables is **withdrawing** from your Shor account to your own bank, whenever you need to. Set this up from **Finance → Connections** by linking your bank. Withdrawals use your country's local rail (ACH, SEPA, UPI, FPS, etc.) and you choose when each one goes out.
See [Your Shor account & withdrawals](/professional/payout-methods) for the full flow.
## Step 6: Get Paid
Once your contract is signed and KYC is verified, your employer can pay you. Each payment credits to your Shor account within minutes of approval. You'll see:
* An email when each payment is approved
* Your balance in **Finance → Accounts** going up shortly after
* A detailed pay stub or invoice in the payment detail view
* Any US tax forms you've signed, available in **Settings → Tax Forms**
Withdraw to your bank when you want. See the next step below.
## Next Steps
See pay history, upcoming payments, and receipts.
Review active and past contracts, request changes.
View and download US tax forms you've signed.
Manage contracts across several employers in one account.