Skip to content
Space Invoices Documentation

Accountants

Use this path when one accounting team or operator manages invoicing for multiple client businesses. The winning model is one entity per client, with your team switching context instead of juggling separate accounts.

Who This Is For

  • accounting firms and outsourced finance teams
  • platforms building an accountant or back-office mode
  • teams that need client switching, exports, and optional client self-service

Best Fit / Not A Fit

Best fit

  • each client is a separate invoicing business
  • one operator or team needs to manage many clients from one account
  • you may want clients to have their own limited access later

Not a fit

  • you only operate one business and never switch contexts
  • you want clients mixed into a single shared document pool
  • you need ERP-wide accounting features beyond document issuance workflows
  • use an account key for your own operations backend
  • use the app or platform UI for client switching
  • add User Access Guide if clients need direct visibility or self-service

Entity Model

Recommended model:

  • one client business = one entity
  • your accounting team remains on one account
  • each entity holds its own customers, items, numbering, and country settings

This preserves clean separation while keeping day-to-day management centralized.

First Sandbox Milestone

Validate this before onboarding many clients:

  1. create two or three sandbox client entities
  2. switch between them
  3. issue one invoice for each
  4. export or render PDFs per client
  5. decide whether clients get no access, API-key access, or user-based access

How It Works

Accounting firm multi-client structure
┌───────────────────────────────────────────────┐
│          Accounting Firm Dashboard            │
├───────────────┬───────────────┬───────────────┤
│   Client A    │   Client B    │   Client C    │
│  entity_123   │  entity_456   │  entity_789   │
├───────────────┼───────────────┼───────────────┤
│  Invoices     │  Invoices     │  Invoices     │
│  Tax Reports  │  Tax Reports  │  Tax Reports  │
│  Documents    │  Documents    │  Documents    │
│  Exports      │  Exports      │  Exports      │
└───────────────┴───────────────┴───────────────┘

Switch Between Clients

Switch clienttypescript
// title: Switch between clients
// Get all clients (entities) for the accountant
const clients = await sdk.entities.list();

// Select a client and fetch their invoices
const selectedClientId = clients.data[0].id;
const _invoices = await sdk.invoices.list({ entity_id: selectedClientId });
List Entities API →

Bulk Operations

Bulk operationstypescript
// title: Bulk export for tax reporting
// Export all invoices for a period
const _exportResult = await sdk.exports.exportDocuments({
  entity_id: client.entityId,
  type: "invoice",
  format: "xlsx",
  dateFrom: "2024-01-01",
  dateTo: "2024-12-31",
});

Give Clients Access (Optional)

Simple approach — Use server-brokered entity API key access only when full client-entity access is acceptable:

Dashboard simpletypescript
// title: Embedded dashboard for client (simple)
const token = await sdk.entityUsers.generateToken(client.entityId, client.userId);

// Redirect client to their dashboard
window.location.href = `https://app.spaceinvoices.com/embed?token=${token}`;

With roles — Use user-based access for controlled permissions:

Dashboard userstypescript
// title: Embedded dashboard for client (with users)
// Add client user to their entity
await sdk.entityUsers.add(client.entityId, {
  email: client.email,
  role: "member",
});

// Generate magic link for client
const token = await sdk.entityUsers.generateToken(client.entityId, client.userId);
const _dashboardUrl = `https://app.spaceinvoices.com/embed?token=${token}`;

See User Access Guide for detailed comparison.

Common Workflow And Gotchas

  • keep one entity per client even when clients look operationally similar
  • do not let exports and PDF runs span entities accidentally unless you mean to aggregate them
  • choose client access deliberately: no access, full entity key access, or user-based access with roles
  • make sure client country and business details are correct before first live invoice issuance
  • use sandbox to verify switching, exports, and templates across multiple client types

Compliance Notes

  • each client inherits compliance behavior from its own entity settings
  • accountant convenience should not override per-client country or numbering rules
  • exports and audit trails should remain client-scoped unless you intentionally aggregate them
  • fiscalization requirements differ by country, so sandbox validation per client profile matters

Why This Model Works

  • Multi-client management — All clients in one place
  • Client isolation — Data stays separate
  • Compliance per client — Each client’s country settings apply
  • Export ready — PDF and data exports for accounting
  • Optional client access — Clients can view or self-serve

Common Workflows

TaskAPI
List all clientssdk.entities.list()
Create invoice for clientsdk.invoices.create({...}, { entity_id })
Get client’s invoicessdk.invoices.list({}, { entity_id })
Export PDFssdk.invoices.renderPdf(id)

Workflow

Accounting firm workflow
┌──────────────┐     ┌─────────────────┐     ┌──────────────┐
│   Client     │     │   Accounting    │     │    Space     │
│   Onboards   │────▶│   Platform      │────▶│   Invoices   │
└──────────────┘     └─────────────────┘     └──────────────┘
                            │                       │
                            │  1. Create entity     │
                            │─────────────────────▶│
                            │                       │
                            │  2. Manage documents  │
                            │─────────────────────▶│
                            │                       │
                            │  3. Generate reports  │
                            │─────────────────────▶│
                            │                       │

Clear Next Action

Create a few sandbox client entities, switch between them, and confirm your team can issue and export documents without crossing client boundaries.