# Tiime API (`tapered_musket/tiime-api-actor`) Actor

Company data, clients, invoices, quotes, bank accounts, transactions, users, billing settings, and related PDF documents.

- **URL**: https://apify.com/tapered\_musket/tiime-api-actor.md
- **Developed by:** [Trapered Musket](https://apify.com/tapered_musket) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Tiime API Exporter and Automation

Connect your Tiime account to Apify, retrieve your business data, and automate common invoicing workflows from a single Actor.

Tiime API Exporter and Automation helps founders, finance teams, accountants, and automation builders work with Tiime data without manual exports from the web app. Sign in with your Tiime account, choose the resource you want to read, create, update, duplicate, convert, or delete, and get structured results in Apify datasets. PDF and other binary files are saved to the key-value store.

Use it as a Tiime data connector, invoice exporter, quote automation tool, or backend action inside Make, Zapier, n8n, internal tools, dashboards, and custom workflows.

### What you can retrieve

- Company profile and configuration
- Clients and client details
- Client contacts and invoicing information
- Invoices, invoice details, statuses, and counters
- Invoice PDFs and related documents
- Quotes, quote details, previews, signatures, and PDFs
- Bank accounts and business accounts
- Unmatched or unimputed bank transactions
- Billing and invoicing settings
- VAT types and country metadata
- Users and feature access
- Dashboard blocks, labels, tags, tiles, and onboarding data
- Subscription and commercial offer information available to the connected account

### What you can automate

- Create new clients
- Update existing clients
- Add contacts to a client
- Update invoice records
- Create credit notes from invoices
- Create quotes
- Update quotes
- Delete quotes
- Duplicate quotes
- Convert quotes into invoices
- Create advance payment invoices from quotes
- Switch the active company for the connected user

### Supported action types

- `GET` requests for exports, syncs, reporting, dashboards, and document retrieval
- `POST` requests for creating clients, contacts, quotes, credit notes, duplicated quotes, invoices from quotes, and advance payment invoices
- `PATCH` requests for updating clients, invoices, quotes, and active company state
- `DELETE` requests for supported deletion workflows, such as deleting quotes

### Common use cases

- Sync Tiime invoices to a BI tool, spreadsheet, database, or internal dashboard
- Export clients and contacts for CRM enrichment
- Retrieve invoice PDFs for archiving or document workflows
- Create clients from external lead or CRM workflows
- Generate quotes from form submissions or internal tools
- Convert accepted quotes into invoices from automation flows
- Monitor invoice status and accounting data from scheduled Apify runs
- Build Make, Zapier, n8n, or custom automations on top of Tiime data
- Prepare structured datasets for reporting, reconciliation, or accounting operations

### How it works

1. Enter the Tiime account email and password.
2. Select the API resource and method you want to run.
3. Add the required path parameters, such as `companyId`, `invoiceId`, or `clientId`.
4. Add query parameters or a JSON body when the operation needs them.
5. Run the Actor.
6. Use the result from the Apify dataset or download it as JSON, CSV, Excel, XML, or RSS.

The Actor also includes a demo mode, enabled by default, so you can preview the output format before connecting an account.

### Example input

Retrieve invoices:

```json
{
  "demoMode": false,
  "email": "user@example.com",
  "password": "your-password",
  "method": "GET",
  "endpointPath": "/v1/companies/{companyId}/invoices",
  "pathParams": {
    "companyId": 123456
  },
  "queryParams": {
    "page": 1
  },
  "pushArrayItems": true
}
````

Create a client:

```json
{
  "demoMode": false,
  "email": "user@example.com",
  "password": "your-password",
  "method": "POST",
  "endpointPath": "/v1/companies/{companyId}/clients",
  "pathParams": {
    "companyId": 123456
  },
  "body": {
    "name": "New client"
  }
}
```

Update a quote:

```json
{
  "demoMode": false,
  "email": "user@example.com",
  "password": "your-password",
  "method": "PATCH",
  "endpointPath": "/v1/companies/{companyId}/quotations/{quotationId}",
  "pathParams": {
    "companyId": 123456,
    "quotationId": 987654
  },
  "body": {
    "status": "draft"
  }
}
```

### Popular read endpoints

```text
/v1/users/me
/v1/companies/{companyId}
/v1/companies/{companyId}/clients
/v1/companies/{companyId}/clients/{clientId}
/v1/companies/{companyId}/invoices
/v1/companies/{companyId}/invoices/{invoiceId}
/v1/companies/{companyId}/invoices/pdf
/v1/companies/{companyId}/quotations
/v1/companies/{companyId}/quotations/{quotationId}
/v1/companies/{companyId}/quotations/{quotationId}/pdf
/v1/companies/{companyId}/bank_accounts
/v1/companies/{companyId}/bank_transactions/unimputed
/v1/companies/{companyId}/invoicing_config
/v1/companies/{companyId}/users
```

### Popular write endpoints

```text
POST   /v1/companies/{companyId}/clients
PATCH  /v1/companies/{companyId}/clients/{clientId}
POST   /v1/companies/{companyId}/clients/{clientId}/contacts
PATCH  /v1/companies/{companyId}/invoices/{invoiceId}
POST   /v1/companies/{companyId}/invoices/{invoiceId}/credit_note
POST   /v1/companies/{companyId}/quotations
PATCH  /v1/companies/{companyId}/quotations/{quotationId}
DELETE /v1/companies/{companyId}/quotations/{quotationId}
POST   /v1/companies/{companyId}/quotations/{quotationId}/duplicate
POST   /v1/companies/{companyId}/quotations/{quotationId}/invoice
POST   /v1/companies/{companyId}/quotations/{quotationId}/invoice_advance_payment
```

### Output

JSON responses are pushed to the default dataset. If an endpoint returns an array, each item can be saved as a separate result, which makes the data easier to filter, export, and connect to other tools.

```json
{
  "endpointPath": "/v1/companies/{companyId}/invoices",
  "method": "GET",
  "statusCode": 200,
  "ok": true,
  "requestedAt": "2026-07-06T00:00:00.000Z",
  "data": {
    "id": "invoice-id",
    "status": "paid"
  }
}
```

Binary responses, such as PDFs, are stored in the default key-value store and referenced from the dataset.

### Authentication

The recommended setup is to connect with your Tiime email and password. Credentials are handled as secret Actor inputs on Apify.

Advanced users can also provide an existing API bearer token instead of account credentials.

### Notes

- The Actor only accesses data available to the connected Tiime account.
- Demo mode does not call Tiime and is useful for testing the Actor output.
- For production automations, schedule runs in Apify and connect the dataset to your preferred downstream tool.

# Actor input Schema

## `demoMode` (type: `boolean`):

Return a sample dataset item without calling Tiime. Useful for Apify Store tests and previews.

## `email` (type: `string`):

Email used to sign in to the Tiime account.

## `password` (type: `string`):

Password used to sign in to the Tiime account.

## `bearerToken` (type: `string`):

Optional advanced authentication token. If not provided, the Actor signs in with email and password.

## `method` (type: `string`):

HTTP method to call.

## `endpointPath` (type: `string`):

OpenAPI path, for example /v1/companies/{companyId}/invoices.

## `pathParams` (type: `object`):

Values used to replace path placeholders such as companyId, invoiceId, clientId.

## `queryParams` (type: `object`):

Query string parameters sent with the request.

## `body` (type: `object`):

JSON body for POST or PATCH requests.

## `pushArrayItems` (type: `boolean`):

When the API returns an array, store each item as a separate dataset item.

## `maxItems` (type: `integer`):

Optional limit when pushing array responses item by item. Use 0 for no limit.

## Actor input object example

```json
{
  "demoMode": true,
  "method": "GET",
  "endpointPath": "/v1/users/me",
  "pathParams": {},
  "queryParams": {},
  "body": {},
  "pushArrayItems": true,
  "maxItems": 0
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("tapered_musket/tiime-api-actor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("tapered_musket/tiime-api-actor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call tapered_musket/tiime-api-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tapered_musket/tiime-api-actor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiime API",
        "description": "Company data, clients, invoices, quotes, bank accounts, transactions, users, billing settings, and related PDF documents.",
        "version": "1.0",
        "x-build-id": "Rk4KCA7cQYeeBRGsT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tapered_musket~tiime-api-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tapered_musket-tiime-api-actor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/tapered_musket~tiime-api-actor/runs": {
            "post": {
                "operationId": "runs-sync-tapered_musket-tiime-api-actor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/tapered_musket~tiime-api-actor/run-sync": {
            "post": {
                "operationId": "run-sync-tapered_musket-tiime-api-actor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "method",
                    "endpointPath"
                ],
                "properties": {
                    "demoMode": {
                        "title": "Demo mode",
                        "type": "boolean",
                        "description": "Return a sample dataset item without calling Tiime. Useful for Apify Store tests and previews.",
                        "default": true
                    },
                    "email": {
                        "title": "Tiime email",
                        "type": "string",
                        "description": "Email used to sign in to the Tiime account."
                    },
                    "password": {
                        "title": "Tiime password",
                        "type": "string",
                        "description": "Password used to sign in to the Tiime account."
                    },
                    "bearerToken": {
                        "title": "Advanced: bearer token",
                        "type": "string",
                        "description": "Optional advanced authentication token. If not provided, the Actor signs in with email and password."
                    },
                    "method": {
                        "title": "HTTP method",
                        "enum": [
                            "GET",
                            "POST",
                            "PATCH",
                            "DELETE"
                        ],
                        "type": "string",
                        "description": "HTTP method to call.",
                        "default": "GET"
                    },
                    "endpointPath": {
                        "title": "Endpoint path",
                        "type": "string",
                        "description": "OpenAPI path, for example /v1/companies/{companyId}/invoices.",
                        "default": "/v1/users/me"
                    },
                    "pathParams": {
                        "title": "Path parameters",
                        "type": "object",
                        "description": "Values used to replace path placeholders such as companyId, invoiceId, clientId.",
                        "default": {}
                    },
                    "queryParams": {
                        "title": "Query parameters",
                        "type": "object",
                        "description": "Query string parameters sent with the request.",
                        "default": {}
                    },
                    "body": {
                        "title": "Request body",
                        "type": "object",
                        "description": "JSON body for POST or PATCH requests.",
                        "default": {}
                    },
                    "pushArrayItems": {
                        "title": "Push array items separately",
                        "type": "boolean",
                        "description": "When the API returns an array, store each item as a separate dataset item.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum array items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional limit when pushing array responses item by item. Use 0 for no limit.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```