EasyData Documentation

Welcome to EasyData! This guide covers everything you need to know to organize and manage your data with AI assistance.

What is EasyData?

EasyData is an AI-assisted data management platform that helps you organize, store, and work with structured data. Whether you’re tracking customers, managing inventory, or organizing any kind of information, EasyData provides a flexible and intelligent way to handle your data.

Key Features

• AI-Assisted Schema Creation — Describe your data in plain language and let AI create the structure for you
• Smart Data Entry — Add entries manually or describe them in natural language
• Schema Relationships — Link your data together with references between schemas
• Formula Fields — Create computed fields with Excel-like expressions that update automatically
• Reports — Build dashboard-style data panels with aggregations, grouping, source filters, and formulas across your schemas
• Field Formats — Customize how data is displayed with formats like currency, email, phone, and more
• Smart Import — Import CSV, TSV, and Excel files with automatic section detection, editable field mapping, and optional AI smart detection
• Intelligent Search — Use embedded fields to enable AI-powered data lookup
• Export Options — Export your data to Excel, CSV, JSON, or Google Sheets, with larger exports handled in the background

Quick Start

Here’s how to get started in just a few steps:

1. Create Your First Schema

1. Navigate to the Schemas page
2. Click Create Schema
3. Choose Assisted mode and describe your data (e.g., “A contact list with name, email, phone, and company”)
4. Click Generate Schemas
5. Review the generated schema and click Create Schemas

2. Add Some Data

Once your schema is created:

1. Click on your schema to open it
2. Click Add Manual Entry to add data using a form
3. Or click Add with AI to describe your data in natural language

3. Organize with References

As your data grows, you can:

1. Create additional schemas for related data (e.g., “Companies” for your contacts)
2. Edit your original schema to add reference fields
3. Link entries together for better organization

Schemas

Schemas are the foundation of EasyData. A schema defines the structure of your data — think of it as a template that describes what information you want to store and how it should be organized.

What is a Schema?

A schema is like a blueprint for your data. For example, if you want to track customers, your schema might include fields like:

• Name (text)
• Email (text with email format)
• Phone (text)
• Active (yes/no)

Once you create a schema, you can add entries (individual records) that follow this structure.

Creating Schemas

The Create schema dialog offers Assisted, Templates, and Manual tabs. The title stays the same when you change method. Assisted generation runs only when you choose Generate Schemas; review the proposed schemas before creating them.

AI-Assisted Creation

The fastest way to create a schema is to describe what you need in plain language:

1. Click Create Schema from the schemas page
2. Select the Assisted tab
3. Describe your data structure in the text area
4. Optionally attach a file for additional context (CSV, Excel, PDF, etc.)
5. Click Generate Schemas
6. Review the generated schema and make adjustments if needed
7. Click Create Schemas to save

Example prompts:

• “A customer database with name, email, phone number, and company”
• “Track my book collection with title, author, genre, and rating”
• “Employee directory with name, department, hire date, and manager”

Templates

Templates give you a ready-made starting point for common workflows. A template can create one schema or a linked set of schemas with references already configured. Template-created schemas are normal schemas: you can edit their fields, add data, link them to projects, and delete them like any schema you create manually.

Some templates can also create a project to keep the related schemas together.

Manual Creation

For full control over your schema structure:

1. Click Create Schema from the schemas page
2. Select the Manual tab
3. Click Add Schema to create a new schema card
4. Enter the schema name
5. Add fields using the Add Field button
6. Configure each field’s properties
7. Click Create Schemas to save

Field Properties

Each field has several configurable properties:

• Display Name — The human-readable name shown in the UI
• Type — Choose Text, Number, Yes/No, or Options for controlled lists
• Required — When enabled, entries cannot be saved without a value in this field
• Default Value — A pre-filled value for new entries
• Hide/Show — Fields can be hidden from the data grid without deleting them
• Format — Controls how data is displayed (e.g., currency, email, phone). See Field Formats
• Formula — An expression that computes this field’s value automatically. See Formula Fields

Schema Naming Rules

Schema names must follow these rules:

• Only letters, numbers, and spaces allowed
• Maximum 50 characters
• Cannot be empty
• No special characters (hyphens, underscores, etc.)

Valid names: “Customers”, “Product List”, “Tasks 2024”

Invalid names: “My-Schema”, “Products_v2”, “Tasks@Work”

Schema Relationships

One of EasyData’s powerful features is the ability to link schemas together using References.

What are References?

A reference field creates a link between two schemas. Instead of typing the same value repeatedly, you select from existing entries in another schema.

Example: You have two schemas:

• Categories: “Electronics”, “Clothing”, “Books”
• Products: Each product references a category

When adding a product, instead of typing “Electronics”, you select it from a dropdown of existing categories.

Creating a Reference Field

1. Edit your schema
2. Add a new field or edit an existing one
3. In the Reference dropdown, select the schema you want to link to
4. Choose a Display Field — this determines what text appears in the dropdown

Converting a Column to a Schema

If you have a field with many repeated values (like categories or statuses), you can convert it into a separate schema:

1. Open your schema’s data grid
2. Hover over the column header and click the database icon
3. Enter a name for the new schema
4. The unique values become entries in the new schema
5. A new reference field is added to your schema, linking to the new schema

Your original field remains unchanged. This is useful for normalizing your data and avoiding typos in repeated values.

Field Formats

Field formats control how data is displayed and entered. They act as display hints — the underlying data type stays the same, but the UI adapts to show it in a more meaningful way.

Available Formats

Setting a Format

1. Edit your schema
2. Select a field
3. Choose a format from the Format dropdown
4. Save the schema

Formula Fields

Formula fields let you create computed columns that calculate their values automatically based on other fields. Think of them like Excel formulas for your data.

How Formulas Work

When you add a formula to a field, that field becomes read-only — its value is computed every time a record is created or updated. You cannot manually edit a formula field.

Writing Formulas

Formulas reference other fields using the $ prefix with the field’s display name:

$quantity * $unitPrice

Arithmetic: +, -, *, /, % (modulo)

Comparisons: ==, !=, >, <, >=, <=

Logical: AND, OR, NOT

Available Functions

Referencing Related Data

Formulas can access fields from referenced schemas using dot notation:

$product.price * $quantity

Here $product is a reference field, and .price accesses the “price” field from the referenced schema.

Aggregation Functions

Aggregation functions compute values across all records in a related schema, filtered by a reference field pointing back to the current record. They are useful for “one-to-many” calculations like totaling all order lines for a customer.

Arguments:

• "Schema" — The name of the related schema (e.g., “OrderItems”)
• "field" — The field to aggregate (not needed for COUNT)
• "referenceField" — The reference field in the related schema that points back to the current schema (e.g., “orderId”)

Examples

Reports

Opening a report from the sidebar or a report card shows Results. This reads the existing results; it does not save a definition or start AI generation. Use Definition to change its name, fields, formulas, grouping or source filters. Schema links open Data, and project links open their contents. The object name stays visible when you switch between content and definition.

Reports let you create data panels that aggregate and summarize data across your schemas. They can show a single row of totals (ungrouped) or break data down into multiple rows using Group By (grouped). Think of them as live dashboards for your data.

What is a Report?

A report is a collection of fields — either static values you enter manually or formulas that compute automatically from your schema data. Reports can also group results by a field, giving you breakdowns like revenue per month or orders by status.

For example, an “Order Summary” report might show:

• Total Revenue — SUM("Sales", "amount")
• Number of Orders — COUNT("Orders")
• Average Order — AVG("Sales", "amount")
• Tax Rate — 0.16 (a static value)
• Estimated Tax — $totalRevenue * $taxRate

Creating a Report

1. Navigate to the Reports page
2. Click New report
3. Enter a name for your report
4. Add fields — choose between Value (static) or Formula (computed)
5. Optionally configure Group By to break results into rows
6. Click Save

Report Fields

Each field in a report has these properties:

• Display Name — The label shown in the report table
• Type — Either “Value” (manual input) or “Formula” (auto-computed)
• Value — For value fields, the number you enter
• Formula — For formula fields, the expression to compute
• Format — How to display the result (number, currency, or percentage)

Report Formulas

Report formulas use the same syntax as schema formulas but with a key difference: aggregation functions operate on all records globally (or within each group when Group By is configured).

Schema Aggregations

Local Field References

Reference other fields within the same report using $:

$totalRevenue * $taxRate

Group By

Group By lets you break a report into multiple rows based on a field from one of your schemas. For example, grouping by a date field with month granularity shows one row per month.

• Schema — The schema to group by
• Field — Which field to use as the group key
• Granularity — For date fields, choose day, month, or year

You can group by multiple fields to create composite breakdowns (e.g., revenue by product and month).

Source Filters

Grouped reports can filter the source records before calculating results. Source filters use the same kind of field/operator/value rules as schema filters, but they apply only to the report’s source schema.

For example, a monthly revenue report can include only records where Status equals “Paid”, or an inventory report can group only products where Active is checked. When a grouped report has source filters, the filters affect the rows, totals, and exports for that report.

Linking Reports to Schemas

You can display reports alongside your schema data:

1. Open a schema’s data grid
2. Click Link reports in the toolbar
3. Select which reports to link
4. Save your selection. Linked reports appear below your data grid; their titles link to the report Results page.

This is useful for seeing totals and breakdowns in context while browsing your data.

Examples

Public API

EasyData’s Public API lets server-side integrations list schemas, read or write records, prepare AI-assisted record creates, and start one-time AI credit checkouts without using the web app.

API Keys

Create and revoke keys from Settings → Developer access → API Keys. Keys are shown once as ed_sk_... secrets. EasyData stores only a hash and identifies keys later by their visible prefix.

Scopes:

• Read only — list schemas, fetch schemas, query records, fetch one record, list credit packages, and check a credit purchase
• Read and write — all read actions plus create schemas, create, update, or delete records, AI-assisted record creation, and starting a credit checkout

Base URL and Auth

Use the /api/public/v1 namespace and send the key as a bearer token:

curl -s "https://easydata.cc/api/public/v1/schemas" 
  -H "Authorization: Bearer $EASYDATA_API_KEY"

Use /api/public/v1/named when you want request and response payloads keyed by field names.

curl -s "https://easydata.cc/api/public/v1/named/schemas" 
  -H "Authorization: Bearer $EASYDATA_API_KEY"

Field IDs and Field Names

The stable API at /api/public/v1 uses immutable field IDs such as f1, f2, and f3. Schema responses include field names and display names so your integration can map labels to stable IDs.

The named API at /api/public/v1/named uses each field’s internal name, such as customerName, in records, filters, and sorting. Records are returned as flat objects, with f1 returned as id. Reference field values remain UUID strings, and related lookup records are also returned with field-name keys.

For retry-safe creates, server integrations may provide deterministic UUIDs. Schema creation keeps a non-empty id, field-ID record creation keeps a valid f1, and named record creation keeps id. Reusing an existing schema or record ID returns 409 Conflict.

For network retries, send an optional Idempotency-Key header on public POST writes: schema create, record create, named record create, and Smart Create. EasyData scopes the key to the API key, method, path, and request body. The same key with the same request replays the stored successful JSON response; the same key with a different request returns 409 Conflict. Failed requests are not cached.

Credit purchases use the UUID requestId in the request body for retry safety. Reuse it only for the identical package purchase. The API returns a Paddle checkoutUrl; the purchase is not complete until the user finishes checkout and its status becomes completed.

Recent Public API requests are visible in Settings → Developer access → API Keys. Logs include method, path, status, duration, request body, and response body for debugging integrations. Authorization headers and raw API key secrets are never stored. Very large bodies are capped and marked as truncated.

Named schema responses return fields as an array with each field’s id, name, displayName, type, and other metadata. If a schema has duplicate field names, use the field-ID API or rename the fields before using the named API.

When creating schemas through the named API, include targetSchemaId on a field to make it a reference field. References always point to the target record id.

Endpoints

Field-ID endpoints:

Named endpoints:

Credit purchase endpoints:

Before creating a credit purchase, show the available package and price to the user and get explicit confirmation. Send { "productId": 1, "requestId": "<uuid>" }, then give the returned checkoutUrl to the user. The user completes payment directly through Paddle Checkout.

Named Curl Examples

Create a schema with field names:

curl -s -X POST "https://easydata.cc/api/public/v1/named/schemas" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Idempotency-Key: schema-orders-001" 
  -H "Content-Type: application/json" 
  -d '{"schemas":[{"id":"018f7f37-78a2-7000-9000-000000000101","name":"Orders","description":"Customer orders","displayField":"customerName","fields":[{"name":"customerName","type":"string","displayName":"Customer Name"},{"name":"amount","type":"number","displayName":"Amount"}],"embeddedFields":["customerName"]}]}'

Query records with field names:

curl -s "https://easydata.cc/api/public/v1/named/schemas/$SCHEMA_ID/records/query?limit=50&offset=0" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"filters":{"fields":[{"field":"customerName","conditions":[{"operator":"contains","value":"Ada"}],"logic":"and"}],"logic":"and"},"orderBy":[{"field":"customerName","direction":"asc"}]}'

Create records with field names:

curl -s -X POST "https://easydata.cc/api/public/v1/named/schemas/$SCHEMA_ID/records" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Idempotency-Key: order-018f7f37-201" 
  -H "Content-Type: application/json" 
  -d '{"records":[{"id":"018f7f37-78a2-7000-9000-000000000201","customerName":"Example customer","amount":42}]}'

Update records with field names:

curl -s -X PATCH "https://easydata.cc/api/public/v1/named/schemas/$SCHEMA_ID/records" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"records":[{"id":"$RECORD_ID","data":{"customerName":"Updated customer"}}]}'

Delete records:

curl -s -X DELETE "https://easydata.cc/api/public/v1/named/schemas/$SCHEMA_ID/records" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"ids":["$RECORD_ID"]}'

Field-ID Curl Examples

Create a schema with field IDs:

curl -s -X POST "https://easydata.cc/api/public/v1/schemas" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Idempotency-Key: schema-orders-001" 
  -H "Content-Type: application/json" 
  -d '{"schemas":[{"id":"018f7f37-78a2-7000-9000-000000000101","name":"Orders","description":"Customer orders","fields":{"f1":{"name":"id","type":"string","order":0,"displayName":"ID"},"f2":{"name":"customerName","type":"string","order":1,"displayName":"Customer Name"},"f3":{"name":"amount","type":"number","order":2,"displayName":"Amount"}},"primaryKey":["f1"],"uniqueKeys":[],"foreignKeys":[],"embeddedFields":["f2"]}]}'

Query records:

curl -s "https://easydata.cc/api/public/v1/schemas/$SCHEMA_ID/records/query?limit=50&offset=0" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"filters":{"fields":[],"logic":"and"},"orderBy":[]}'

Create records:

curl -s -X POST "https://easydata.cc/api/public/v1/schemas/$SCHEMA_ID/records" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Idempotency-Key: record-018f7f37-201" 
  -H "Content-Type: application/json" 
  -d '{"records":[{"f1":"018f7f37-78a2-7000-9000-000000000201","f2":"Example value","f3":42}]}'

Create records with AI:

curl -s -X POST "https://easydata.cc/api/public/v1/smart-entry/create" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Idempotency-Key: smart-order-acme-001" 
  -H "Content-Type: application/json" 
  -d '{"message":"Add an order for Acme for 2400 due tomorrow","schemaIds":["$SCHEMA_ID"],"autoSave":false}'

schemaIds is optional but recommended when your integration already knows the target schema. With autoSave: false, EasyData returns proposed records using field IDs. With autoSave: true, EasyData saves create-only results through the same validation, history, formula, embedding, report, and record-count behavior as the records API.

Update records:

curl -s -X PATCH "https://easydata.cc/api/public/v1/schemas/$SCHEMA_ID/records" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"records":[{"id":"$RECORD_ID","data":{"f2":"Updated value"}}]}'

Delete records:

curl -s -X DELETE "https://easydata.cc/api/public/v1/schemas/$SCHEMA_ID/records" 
  -H "Authorization: Bearer $EASYDATA_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"ids":["$RECORD_ID"]}'

V1 intentionally does not include schema editing, imports, full Smart Entry continuation flows, reports, widgets, or browser/public keys.

Connect AI Agents

EasyData lets AI agents connect to a user’s account without asking the user to copy an API key. The agent registers as a public OAuth client, the user signs in and approves access, and EasyData issues credentials limited to the approved resource and scope.

Clients and User Connections

A client_id identifies the agent application, not an EasyData user. It is a public identifier and is safe to include in authorization requests. One client can connect to multiple users, but every user must approve a separate grant and receives a separate access-token and refresh-token family.

Each active connection is unique to a user, client, and resource. Users can review and immediately revoke their grants from Settings → Integrations & agents → Connected Agents.

Authorization Flows

Both flows create the same kind of connection and issue the same token types. Authorization codes and claim tokens are short-lived, single-use intermediates; they cannot call the API themselves.

Resources, Scopes, and Tokens

• REST resource — https://easydata.cc/api/public/v1
• MCP resource — https://easydata.cc/api/mcp
• Read — list or get schemas, query or get records, list credit packages, and check credit purchases
• Read and write — all read actions plus schema creation, record writes and deletes, Smart Entry, and starting a confirmed credit checkout

Access tokens are signed bearer tokens valid for one hour. Refresh tokens are opaque credentials valid for up to 30 days and rotate on every use. Store access and refresh tokens as secrets. Reusing a refresh token after it has rotated revokes the entire connection.

Discovery and Integration

Agents should start with EasyData’s machine-readable discovery documents instead of hard-coding endpoint details:

• OAuth authorization-server metadata
• Protected-resource metadata
• Agent authentication guide
• Agent Skills index
• MCP Streamable HTTP endpoint: /api/mcp

For example, an agent can discover every OAuth endpoint with:

curl -s "https://easydata.cc/.well-known/oauth-authorization-server"

The client registration response returns a client_id. The agent stores and reuses that public identifier, but stores each user’s refresh token separately and never exposes tokens in URLs, browser bundles, logs, or chat.

Embedded Fields

Embedded fields enable a powerful AI feature: when you add entries using the AI assistant, it can search and reference your existing data.

What are Embedded Fields?

When you mark a field as “embedded”, its values are indexed in a vector database. This allows the AI to find relevant entries when you describe data in natural language.

How It Works

1. You mark fields like “Name” or “Email” as embedded in your schema
2. The system syncs these values to the search index (you’ll see a sync status indicator)
3. When adding entries via AI, you can reference existing data naturally

Example:

You have a “Contacts” schema with “Name” marked as embedded, containing an entry for “John Smith”.

When adding a task, you can say: “Create a follow-up task for John”

The AI will:

1. Search your embedded fields for “John”
2. Find “John Smith” in your Contacts
3. Automatically link the task to the correct contact

Good Candidates for Embedding

Choose fields that help identify entries:

• Names (person names, product names, company names)
• Email addresses
• Descriptions
• Titles

Enabling Embedded Fields

1. Edit your schema
2. Find the field you want to embed
3. Toggle the Embedded switch
4. Save the schema
5. Wait for the sync to complete

Managing Data

Once you’ve created a schema, you can start adding and managing data entries.

Viewing Your Data

Click a schema card or sidebar schema name to open Data. This spreadsheet-like interface shows your records. Choose Definition to configure fields, types, formulas and references; choose Data to return to the records.

Adding Entries

Manual Entry

For precise control over your data:

1. Click Add Manual Entry in the toolbar
2. A new empty row appears at the top of the grid
3. Fill in each field by clicking the cells
4. Press Enter to save and create another entry, or Escape to cancel

AI-Assisted Entry

Let AI help you convert natural language into structured data:

1. Click Add with AI in the toolbar
2. Describe your data in plain language
3. Review the converted data in the preview
4. Click to add the entries to your schema

Example prompts:

• “Add a customer named John Smith, email [email protected], phone 555-1234”
• “Create three products: Widget A for $19.99, Widget B for $29.99, Widget C for $39.99”
• “Add a task to follow up with the marketing team about the Q1 report”

You can also use voice input by clicking the microphone icon.

Importing Files

For existing spreadsheets or tabular files:

1. Open the schema you want to import into
2. Click Import in the toolbar
3. Upload a CSV, TSV, XLS, or XLSX file
4. Review the detected file section and column-to-field mapping
5. Adjust any mapped fields or skip columns you do not want to import
6. Click Import to create the records

EasyData automatically detects the best importable section in the file and suggests a mapping from file columns to schema fields. This helps with spreadsheets that have extra headings, blank rows, multiple regions, or field/value layouts instead of a simple table.

If the detected section or mapping does not look right, use Smart detect with AI from the review step. Smart detection uses AI credits to choose the best section and mapping for the selected schema, then returns you to the same review screen so you can confirm before importing.

You can also attach tabular files while using Add with AI. When EasyData detects that an uploaded file is better handled as an import, it shows an import review offer so you can inspect the mapping before records are created.

Editing Entries

Inline Editing

The fastest way to edit data:

1. Click on any cell in the data grid
2. Type the new value
3. Press Enter to save, Tab to move to the next cell, or Escape to cancel

Changes are saved automatically when you leave a cell.

Reference Fields

When editing a reference field:

1. Click the cell to open a dropdown
2. Search or scroll to find the entry you want
3. Click to select it

Filtering and Sorting

Sorting

Open Sort in the toolbar to choose a column and ascending or descending order, or clear the sort. Its count shows the active sort rules. The column chevron also offers Sort and filter as a shortcut.

Filtering

Use the filter options to narrow down your data:

1. Open Filter in the toolbar, or Sort and filter from a column’s chevron
2. Select the field and an operator (equals, contains, greater than, etc.)
3. Enter the filter value
4. Apply the filter. The toolbar count shows fields with active filters

Filtering and sorting affect the current table. Save a filter when you want to reuse it. Imported-file chips are shown separately because they identify the source of imported records.

Available filter operators:

Configure View

Open View options in the schema toolbar for presentation controls:

• Column visibility and order opens a draft in the grid. Add or hide columns, drag to reorder, then choose Apply to save or Cancel to discard.
• Density and column widths apply immediately and stay in this browser.
• Conditional coloring uses Save to store your rules. Column visibility/order and conditional rules are personal settings for this account, workspace and schema.
• Cell colors change shared record metadata immediately, so other people with access to those records can see them.

When you have reference fields, you can add columns from the referenced schema to display related data inline. Definition controls the schema’s fields and types; hiding a view column does not remove its field or records. Saved filters retain their existing behavior and do not save a complete view.

Export Data

Export your data in multiple formats for sharing, backup, or integration with other tools.

Export Formats

How to Export

1. Open a schema’s data grid
2. Click Export Data in the toolbar
3. Select your preferred format
4. Small exports are created immediately
5. Larger exports are processed in the background and appear in the export tray when ready
6. For Google Sheets, the completed export provides a link to the new spreadsheet

What Gets Exported

• All visible columns in your current view configuration
• Reference fields are resolved to show actual values (e.g., product names instead of IDs)
• Active filters and sort order are applied to the export
• Report exports follow the report’s grouping and source filters
• Background export files are available from the export tray for a limited time

Edit History

EasyData tracks all changes to your entries:

1. Click History in the toolbar (clock icon)
2. View a timeline of all changes
3. See what was changed and when
4. View before/after values for each edit

For each change, you can see:

• Timestamp — When the change occurred
• Operation — Create, Update, or Delete
• Entry ID — Which entry was affected
• Changed Fields — Which fields were modified
• Before/After Values — The old and new values

Data Validation

EasyData validates your entries based on the schema definition:

• Required Fields — Must have a value before saving
• Type Validation — Values must match the field type (numbers, booleans, etc.)
• Format Validation — Email and URL formats are checked

When possible, EasyData automatically converts values (e.g., empty strings in number fields become null, “true”/“false” strings convert to booleans).

Tips for Success

Start Simple

Begin with a basic schema and add complexity as needed. You can always add new fields or create relationships later.

Use AI Assistance

Don’t hesitate to use the AI features! Whether creating schemas or adding data, describing things in plain language often saves time.

Leverage References

Instead of typing repeated values (like categories or statuses), create a separate schema and use references. This prevents typos and makes updates easier.

Enable Embedded Fields

For schemas you’ll reference frequently (like Contacts or Categories), enable embedded fields on identifying information. This makes AI-assisted entry much more powerful.

Export Regularly

Use the Export feature to back up your data or share it with others in Excel format.

Classifications and breakdowns

A classification owns its grouping structure, rules, and calculations. Open Edit classification to change a grouping’s field or rules directly, reorder it, or adjust its conditions. Review the preview, then choose Save classification. Changes apply only to that classification.

Choose Use on another schema to create an independent copy. Select the destination schema and map each input to one of its fields. Matching field names and types are suggested; review them before saving. The copy keeps the rules and calculations, but has its own source mappings. It does not copy records or manual result corrections, and later edits do not update the original.

Single-schema creation prepares the mappings automatically. Sources and field mappings lets you review them or configure multiple sources. Required inputs must have a compatible mapping; optional inputs may explicitly be empty.

All classifications let you edit grouping rules and fields inline, including classifications used by reports. Advanced scopes, calculations, category customizations and manual corrections stay connected. Editing a shared grouping creates an independent copy for that classification. Template-based classifications retain their explicit upgrade options.

A classification definition contains reusable rules and generators. A schema application, also called a binding, maps its inputs to fields in one schema and pins a published version. Editing a draft does not change existing applications. Validate the draft before publishing, then update each application explicitly when ready.

For a bank statement, map the Amount input to the amount field and apply Amount bands. Apply Calendar month to the transaction date to group January through December. Year-month keeps January in different years separate. Rule categories can distinguish business transactions from personal transactions using conditions on the merchant or description.

One category per record selects the first matching category. Move up and Move down buttons set the priority and work with the keyboard. Multiple categories per record can classify one transaction as both Business and Tax deductible. A filter using All selected categories finds transactions that have both tags.

Generated categories come from the source values. You can change their labels, description, color, and order without changing source records. Hiding a category affects presentation. Merging categories combines their meaning; overlapping record counts can include the same record twice. Use the displayed impact before applying a merge.

Manual assignment changes the effective classification of selected records. For overlapping categories, include and exclude control each category separately. These corrections survive rule updates until you choose Return to automatic. Leave unclassified intentionally removes an exclusive assignment. Unclassified means no effective category, rather than a missing source record.

A breakdown composes classifications into a tree, for example Month → Amount band → Transaction category. A record-scope node evaluates each record using its existing classification. Parent-partition scope recomputes thresholds or rankings within the parent bucket, so per-month quantiles can differ from fixed amount bands. Parent-group scope classifies an aggregate, such as the monthly total, rather than each transaction. A record sample does not represent the full population needed for contextual thresholds.

Reports can group by a field, classification, or saved breakdown at a selected depth. Overlapping totals are not additive. A transaction included in two categories contributes to both groups. Adding group totals can exceed the original schema total. Reference fields retain their usual display labels.

Preview shows a bounded sample and never saves computed results. Ready means an active generation is available. Stale means the source or rules changed since that generation. Computing keeps the previous successful results visible until the new run succeeds. If computation fails, inspect the bounded error summary and retry after correcting the cause.

Templates reuse a breakdown structure and pin a version. Review input mappings and an upgrade preview before applying an upgrade. Forking creates an independent template. A copied definition or template needs its own schema applications.

Reuse a classification

Choose Use on another schema, select the destination for each source or related schema, and map its fields. Check mappings validates the entire classification before Create independent copy. This includes conditional branches, rankings, calculated ranges, expressions, group totals and named calculations.

The copy keeps category labels, hidden categories, merges and hierarchy. It calculates new results from the destination records. Existing reports, run history and record-specific corrections remain with the original classification. Editing either classification does not change the other.