Can Your FileMaker Do This? Make Your Data Easier for AI to Understand

Yes — FileMaker 2026 lets developers add plain-English annotations to tables and fields, so both people and AI tools understand what the data actually means.

The Idea

Most FileMaker systems contain more than data. They contain years of business knowledge.

The challenge is that much of that knowledge is not always obvious from the field or table names alone.

A field called “Status” might mean something very specific inside your business. A date field might represent a requested ship date, a promised delivery date, or an internal deadline. A checkbox might trigger an important workflow that only certain users understand.

People who use the system every day may know what those fields mean. AI tools may not.

With FileMaker 2026, developers can add more context to tables and fields through annotations and comments. That means the system can better describe what its own data represents.

For example, annotations can help explain:

  • What a table is used for
  • What a field means in business terms
  • How a status should be interpreted
  • Which dates matter for reporting
  • Which fields are important for search, dashboards, or AI-assisted workflows

Why It Matters

AI tools are only as useful as the context they are given.

If an AI model encounters a field labeled “Due Date,” it may not know whether it refers to the customer’s deadline, the internal production deadline, or the expected invoice date. If it sees a status called “Hold,” it may not know whether that means waiting on materials, waiting on approval, or paused by the customer.

That lack of context can lead to confusion or inaccurate results.

By documenting tables and fields more clearly, businesses can make FileMaker data easier for both people and AI systems to understand. This can improve natural-language queries, semantic search, reporting, and future AI-assisted workflows.

It also helps developers and internal teams maintain the system more confidently over time.

Who Benefits From It

This is especially useful for companies with mature FileMaker systems.

Older systems often contain years of custom logic, naming conventions, exceptions, and business-specific terminology. Long-time users may understand those details, but new employees, outside developers, and AI tools may not.

Operations teams benefit when reporting fields are easier to interpret. Managers benefit when natural-language questions return more accurate results. Developers benefit when the system’s structure is easier to understand and maintain.

It is also useful for businesses preparing to use more AI inside or alongside FileMaker.

How It Works

A practical first step is to review the most important tables and fields in your FileMaker system.

Start with the areas that matter most for reporting, search, workflows, or decision-making. For example: Jobs, Orders, Customers, Inventory, Invoices, Projects, or Service Requests.

Then add plain-English descriptions that explain what each table or field means.

A table comment might explain that the Jobs table stores active and historical production jobs. A field annotation might explain that “Target Ship Date” refers to the date operations are working toward, not necessarily the customer’s originally requested date.

The goal is not to document every field at once. Start with the tables and fields that AI tools, dashboards, reports, or users are most likely to rely on.

Bottom Line

If your business wants to get more value from AI, one of the best places to start is with clearer data.

FileMaker 2026 gives developers a practical way to add context directly to tables and fields. That context can make the system easier to understand, easier to maintain, and better prepared for AI-assisted workflows.

The data may already be there. The opportunity is helping FileMaker, your team, and your AI tools understand what that data actually means.

Kyo Logic — custom Claris/FileMaker and manufacturing software, New England — helps businesses document mature FileMaker systems so they are ready for AI-assisted workflows.

Can your FileMaker do this? With FileMaker 2026, it can tell your AI what its own data means.

Frequently asked questions

Can I add descriptions to FileMaker fields and tables?

Yes. FileMaker 2026 supports annotations and comments on tables and fields, separate from the field or table name itself.

Does this require rebuilding the database structure?

No. Annotations are added on top of the existing structure. They document meaning without changing how the system works.

Which fields should be documented first?

Start with the tables and fields most used for reporting, search, or AI-assisted workflows, such as Jobs, Orders, or Customers.

Can Your FileMaker Do This? Build a Modern Dashboard from the Data You Already Have

Yes: If your FileMaker system already tracks jobs, orders, materials, or quality issues, you can turn that data into a live operational dashboard without rebuilding anything.

Most FileMaker systems already contain the data a business needs to make better decisions. The problem is that the information is often scattered across layouts, reports, portals, and workflows designed for daily operations rather than for quick visibility.

A modern dashboard brings that information together in one place.

For example, a manufacturing company might want to see:

  • Jobs that are behind schedule
  • Materials causing production delays
  • Orders at risk of missing delivery dates
  • Quality issues requiring attention
  • Production throughput by department

In many cases, all of that data already exists in FileMaker. A dashboard simply makes it easier to see and act on.

Why It Matters

The best dashboards do more than display data; they help people make decisions.

Instead of digging through multiple screens or exporting spreadsheets, users can quickly identify:

  • What needs attention today
  • Where bottlenecks are forming
  • Which trends are improving or declining
  • What actions should be taken next

A production manager can spot delayed jobs before they affect customers. An operations leader can identify workflow issues across departments. Executives can monitor key performance indicators without waiting for reports.

Who Benefits Most?

Modern dashboards can provide value across nearly every level of an organization.

Operations teams gain visibility into daily workloads and bottlenecks. Managers can monitor performance, track progress, and identify issues before they become larger problems. Executives get a high-level view of key metrics without relying on manually prepared reports.

Dashboards are especially valuable for businesses that have accumulated years of operational data in FileMaker but struggle to turn that information into actionable insights. If your team spends time searching for answers instead of acting on them, a dashboard can often make an immediate impact.

What Makes a Dashboard Effective?

Successful dashboards answer a few simple questions:

  • What needs attention right now?
  • What is trending in the wrong direction?
  • What decisions need to be made today?

Before building a dashboard, it’s important to determine which metrics matter most, who needs access, and what actions users should take based on the information.

Otherwise, it’s just another screen full of charts.

The Bottom Line

If you’re looking for a practical FileMaker modernization project, dashboards are often one of the fastest ways to deliver value.

The data is usually already there. The opportunity is making it easier to see, understand, and act on. A great dashboard isn’t decoration; it’s a decision-making tool.

Kyo Logic — custom Claris/FileMaker and manufacturing software, New England — builds dashboards directly on top of the FileMaker systems businesses already run. For a step-by-step walkthrough, see How to Build a Practical FileMaker Dashboard from Existing Operational Data.

Can your FileMaker do this? If the data is already there, the dashboard is closer than you think.

Frequently asked questions

Can a FileMaker dashboard use data I already have?

Yes. Most manufacturing and operations dashboards pull directly from data already stored in FileMaker, including jobs, orders, materials, and quality records.

Do I need to rebuild my FileMaker system to add a dashboard?

No. A dashboard is a new way of viewing existing data. It does not require restructuring the underlying system.

Who should see the dashboard first?

Start with the team closest to the bottleneck, often production managers or operations leads, before rolling it out company-wide.

Rich Text Editor: a reusable formatting toolbar for any FileMaker field

Free FileMaker add-on

Rich Text Editor: a reusable formatting toolbar for any FileMaker field

Give users a familiar editor for notes, templates, and client-facing text, and set it up once for as many fields as you need.

You can add a full rich text editor to FileMaker with a web viewer, and you only need to build it once. Kyo Logic’s free Rich Text Editor add-on runs the Summernote editor inside a web viewer, lets you set up as many separate configurations as you need, and writes changes back to the connected FileMaker field as the user types.

Here is the moment it exists for. Your team writes the scope section of every quote in FileMaker. Someone needs a bulleted list, a bold warning, and a link to the spec sheet. They write it in Word, paste it in, and the formatting falls apart. Next week a different screen needs a stripped-down notes editor, and a developer starts building a second editor from scratch.

Why does rich text get complicated in FileMaker?

FileMaker text fields support basic character styling from the Format menu, but users now expect a toolbar: lists, headings, links, and the buttons they know from every web app. Embedding one editor in a web viewer is a reasonable afternoon of work.

The hard part is the second and third editor. One screen needs three buttons. Another needs the full set for templates and documentation. Each new editor usually means new scripts and new plumbing between the web viewer and the field. That is the part this add-on was built to remove.

What the add-on does out of the box

  • Built on Summernote. Summernote is a well-documented open source editor, so its options and behaviors are clearly defined, and it is simple enough that configuration changes stay easy.
  • Many configurations, one component. Create as many standalone configurations as you need, each pointing to a different field. Keep one minimal and give another the full toolbar.
  • The FileMaker communication is already handled. The link between the editor and FileMaker is abstracted out, so adding a configuration does not mean writing new scripts or field-level plumbing.
  • Background saves. The editor updates the connected field as the user types.

You create a configuration and point it at a field

↓

You choose the toolbar options that screen needs

↓

A user opens the layout and edits in a familiar toolbar

↓

The editor writes the content back to the field in the background

Why a repeatable pattern beats a one-off editor

The value is not rich text on one screen. It is having a pattern you can reuse every time a new use case appears, without starting over. A quote template, a product description, a client update, and an internal procedure can each get the editor they need from the same component.

Because Summernote has a fairly extensive API, there is room to go further when a solution needs more than the default setup. And if you are already improving the screens your team writes on, the Multi-File Uploader handles the attachments that usually sit next to that text, and the Audit Log & Version History add-on records who changed it.

What this could look like in your solution

Start with the field people complain about most. Usually that is the one where formatted text matters to a customer: quote scopes, job instructions, or report narratives. Give it the full toolbar. Then give internal notes a lighter version so nobody is distracted by buttons they never use.

Kyo Logic builds custom Claris FileMaker and manufacturing software for businesses across New England and beyond. If you want help deciding which fields deserve rich text, keeping formatted content consistent in printed and emailed output, or extending the editor with Summernote’s API, reach out.

Frequently asked questions

Does FileMaker have a built-in rich text editor?

FileMaker text fields support basic character styling from the Format menu, but there is no built-in toolbar editor with lists, headings, and links. A web viewer editor such as Summernote fills that gap.

What is the Kyo Logic Rich Text Editor built on?

It is built on Summernote, a well-documented open source editor, running inside a FileMaker web viewer.

Can I use different toolbars on different layouts?

Yes. You can create many standalone configurations, each pointing to a different field, so one can stay minimal while another offers the full set of tools.

Do I need to write new scripts for every field?

No. The communication between the editor and FileMaker is abstracted out, so adding a configuration does not require new scripts. The editor updates the field as the user types.

Quick takeaways

  • Pick the one field where formatted text matters most to customers and start there.
  • Use a minimal toolbar for internal notes and a full one for templates and client-facing text.
  • Check how formatted content looks anywhere it leaves FileMaker, such as printed reports and emails.
  • Download the add-on and set up two configurations to see the difference.

Get the Rich Text Editor add-on

Tell us where to send it and we will email your download link right away.

Interactive Web Forms with FileMaker Data via Claris Studio

FileMaker 2025 introduces major enhancements to FileMaker Server, helping organizations scale their solutions across larger teams, heavier workloads, and high-availability environments. With ARM-based cloud options, improved caching, and performance optimizations throughout the engine, FileMaker Server is now better equipped than ever for enterprise deployments.

 

ARM-Based Cloud Servers for Better Efficiency

Claris now supports ARM-based hosting environments for FileMaker Server, offering:

  • Lower compute costs
  • Improved energy efficiency
  • Faster parallel processing
  • Better scalability for cloud workloads

These environments excel on containerized or virtualized platforms, where ARM architectures continue to gain adoption.

 

Improved Caching and Memory Management

FileMaker Server 2025 introduces smarter caching strategies that reduce disk access and improve responsiveness for:

  • Large datasets
  • High-traffic scripts
  • Repetitive query patterns
  • Multiuser environments

Alongside threading improvements and memory optimization, these changes make Server more stable under load (especially for teams with dozens or hundreds of simultaneous connections).

 

Best Practices for Uptime and Failover

To fully leverage the new performance model, organizations should implement:

  • Automated nightly backups with incremental snapshots
  • Failover clustering in cloud-based environments
  • Scheduled script engine resets for long-running processes
  • Health monitoring using new Admin API endpoints
  • Load-balanced WebDirect instances, where applicable

These strategies help ensure uptime, especially in mission-critical settings.

 

Why it Matters

High-performance server capabilities expand FileMaker’s role within enterprise environments. Organizations benefit from:

  • Faster app response times
  • Greater reliability under heavy workloads
  • Lower infrastructure costs
  • More predictable scaling
  • Better experiences for end users and external clients

FileMaker Server 2025 is now a serious contender for enterprise-grade application delivery.

Need help scaling FileMaker for a high-volume environment? Reach out to Kyo Logic here.

 




High-Performance FileMaker Server: Scaling for Enterprise Workloads

FileMaker 2025 introduces major enhancements to FileMaker Server, helping organizations scale their solutions across larger teams, heavier workloads, and high-availability environments. With ARM-based cloud options, improved caching, and performance optimizations throughout the engine, FileMaker Server is now better equipped than ever for enterprise deployments.

ARM-Based Cloud Servers for Better Efficiency

Claris now supports ARM-based hosting environments for FileMaker Server, offering:

  • Lower compute costs
  • Improved energy efficiency
  • Faster parallel processing
  • Better scalability for cloud workloads
     

These environments excel in containerized or virtualized platforms, where ARM architectures continue gaining adoption.

Improved Caching and Memory Management

FileMaker Server 2025 introduces smarter caching strategies that reduce disk access and improve responsiveness for:

  • Large datasets
  • High-traffic scripts
  • Repetitive query patterns
  • Multiuser environments
     

Alongside threading improvements and memory optimization, these changes make Server more stable under load—especially for teams with dozens or hundreds of simultaneous connections.

Best Practices for Uptime and Failover

To fully leverage the new performance model, organizations should implement:

  • Automated nightly backups with incremental snapshots
  • Failover clustering in cloud-based environments
  • Scheduled script engine resets for long-running processes
  • Health monitoring using new Admin API endpoints
  • Load-balanced WebDirect instances, where applicable
     

These strategies help ensure uptime, especially in mission-critical settings.

Why It Matters

High-performance server capabilities expand FileMaker’s role within enterprise environments. Organizations benefit from:

  • Faster app response times
  • Greater reliability under heavy workloads
  • Lower infrastructure costs
  • More predictable scaling
  • Better experiences for end users and external clients
     

FileMaker Server 2025 is now a serious contender for enterprise-grade application delivery.

Need help scaling FileMaker for a high-volume environment?
Reach out to Kyo Logic here.

 

GetFieldsOnLayout and Dynamic UI Creation

FileMaker 2025 introduces a new function that’s small in name but huge in impact: GetFieldsOnLayout. This addition allows developers to dynamically retrieve all fields that exist on a given layout, making it easier than ever to create adaptive, data-aware user interfaces that respond intelligently to context and user permissions.

Smarter, More Flexible Interfaces

Traditionally, UI updates in FileMaker required developers to hard-code field lists or manually update scripts whenever layouts changed. With GetFieldsOnLayout, you can now query which fields exist on any layout at runtime.

That means you can:

  • Automatically build record views or reports that adapt to layout changes
  • Filter available fields by user role, record type, or access level
  • Dynamically display or hide fields without editing scripts manually

This dramatically reduces maintenance overhead and makes your apps more resilient as layouts evolve.

 

How It Works

GetFieldsOnLayout ( layoutName ) returns a JSON array of all fields currently present on the specified layout. Developers can then parse this JSON and use it to power dynamic UI generation, reporting logic, or layout-aware automation.

Example use case:

A developer might build a script that automatically populates dropdowns or data grids based on the fields found in a layout. If a field is added or removed later, the UI updates automatically. No script changes required.

 

Building Dynamic Dashboards and Reports

The combination of GetFieldsOnLayout with FileMaker’s JSON and scripting functions opens up exciting new possibilities:

  • Dynamic dashboards that automatically populate charts or KPIs based on layout fields.
  • Role-based interfaces that hide sensitive data depending on user privilege.
  • Smart reporting tools that adapt to layout changes without developer intervention.

These capabilities make FileMaker more modular, data-driven, and scalable for organizations with evolving business needs.

Why It Matters

By introducing GetFieldsOnLayout, FileMaker 2025 eliminates one of the biggest friction points in UI management: keeping your front-end synchronized with your schema. Developers can now build smarter, more responsive apps that require less maintenance and deliver a better user experience.

Conclusion

GetFieldsOnLayout is a deceptively simple addition that unlocks powerful, dynamic UI capabilities in FileMaker 2025. Whether you’re generating adaptive dashboards, automating reports, or managing user-specific layouts, this function helps your app evolve as your data does.


Want to learn how Claris FileMaker’s new development tools can simplify your app design and automation? Reach out to Kyo Logic here.




Faster Scripting: Code Folding and Navigation Updates

FileMaker 2025 introduces major improvements to the Script Workspace, enabling developers to navigate complex scripts more quickly and write cleaner, more maintainable code. 

These updates, which focus on code folding, enhanced navigation tools, and improved organizational controls, make scripting more efficient for both new and experienced developers.

Code Folding: Simplify Complex Logic

One of the most welcome additions to Script Workspace is code folding. Developers can now collapse or expand sections of scripts, making it easier to manage lengthy processes.

Instead of scrolling through hundreds of lines, you can:

  • Collapse loops, conditional branches, or repetitive routines
  • Focus on the logic you’re actively editing
  • Keep scripts tidy for easier debugging and collaboration

This feature is especially valuable in enterprise solutions, where scripts often span multiple workflows and layouts.

 

Improved Navigation and Organization

FileMaker 2025 also introduces smarter navigation options inside Script Workspace, designed to reduce friction during development. Developers can:

  • Jump quickly between script sections or functions
  • Use search and filter tools to find steps by name or keyword
  • Navigate through scripts with clearer visual cues and indentation

Combined with the new Go to List of Records script step and enhanced script grouping, these updates make the workspace feel faster and more intuitive (especially when working across multiple scripts or modules).

Why It Matters for Developers

For anyone managing large, logic-heavy solutions, the new Script Workspace saves time at every turn. Developers can organize scripts by purpose, collapse logic when not in use, and find specific actions in seconds. Over time, these workflow improvements add up to significant productivity gains.

Beyond convenience, these updates also improve collaboration and maintainability. Clean, well-organized scripts are easier for teams to understand and modify, reducing onboarding time and preventing costly errors.

The Script Workspace updates in FileMaker 2025 give developers the clarity and control they’ve been asking for. With code folding, faster navigation, and smarter organization tools, building complex scripts is now faster, cleaner, and far more manageable.

Want to modernize your FileMaker environment and take advantage of these new scripting tools? Reach out to Kyo Logic here.




FileMaker Cloud 2025: What This Means for Modern FileMaker Deployments

Claris has announced that FileMaker Cloud 2025 (v2.22) is arriving in November, bringing faster performance, new security updates, and a few critical compatibility changes.

For most developers, this release isn’t about flashy new features; it’s about alignment: keeping your apps compatible, secure, and future-ready as the FileMaker platform continues its cloud-first evolution.

Why It Matters

The new FileMaker Cloud version introduces an updated security infrastructure, improved monitoring, and performance optimizations, all built on the same Ubuntu foundation as FileMaker Server 2025.

But the real story is compatibility: older clients won’t connect after the upgrade. That means organizations running legacy versions of FileMaker Pro or Go need to update before November 6 to avoid user lockouts or connection errors.

In other words: If you’re running FileMaker Pro earlier than 20.3.2 or FileMaker Go before version 21, plan your upgrades now.

What’s New

FileMaker Cloud 2025 brings:

  • Enhanced encryption and security certification (SOC 2 Type 2, ISO/IEC)
  • Expanded AWS region support for better regional performance and compliance
  • Proactive infrastructure management handled entirely by Claris (patching, updates, OS maintenance)
  • Improved version-checking tools so admins can automatically prompt users to update

Together, these updates continue Claris’s push toward a self-maintaining, secure, and scalable FileMaker environment (especially for organizations ready to offload infrastructure management). 

How to Prepare

If you’re an administrator:

  • Audit your connected clients.
    Use the Admin Console’s Access.log or Claris’s sample file to check which FileMaker Pro/Go versions are still in use.
  • Set up an upgrade prompt.
    You can script a simple version check using Get ( ApplicationVersion ) on file open. Claris even provides a template!
  • Review your maintenance schedule.
    Manual upgrades open November 6, and systems with automatic maintenance will update during their next scheduled window.

For teams that rely on continuous uptime, this is a good opportunity to test in a staging environment before upgrading production systems.

Where It Fits

Claris continues to narrow the gap between on-premise and cloud deployments, with FileMaker Cloud now offering many of the same administrative controls as FileMaker Server (but without the maintenance burden).

For Kyo Logic clients, we see FileMaker Cloud 2025 as a strong fit for:

  • Teams that need enterprise-grade security without managing servers
  • Organizations with distributed workforces or multi-region access needs
  • Businesses planning to integrate Claris Connect or AI-driven features that depend on modern infrastructure

If you’re still hosting your own FileMaker Server but curious about the cloud transition, this release makes the case stronger than ever.

Kyo Logic’s Take

Claris isn’t just maintaining the platform; they’re future-proofing it. With FileMaker Cloud 2025, the company is making sure that as FileMaker continues to integrate AI, APIs, and data services, your infrastructure won’t hold you back.

We recommend using this update window to:

  • Confirm client version compliance
  • Evaluate whether your hosting environment still fits your operational goals
  • Explore modernization opportunities, like hybrid AI or analytics layers built on FileMaker 2025
     

Need help preparing or auditing your deployment?

We’re helping clients plan clean upgrade paths now before the November rollout.

Contact us to make sure your systems are ready.




Can Your FileMaker Do This? Mini JSON Use Cases

1) A readable audit trail without extra fields

What: Keep a simple change log per record as JSON (who changed what, and when).
Why: Easier reviews and handoffs; no more scattering “_old/_new” fields across the table.
How: On commit, append one JSON entry to an “AuditJSON” field.

// Append one change entry (example for a Status change)

Set Variable [ $entry ;

  JSONSetElement ( “{}” ;

    [ “timestamp” ; Get ( CurrentTimestamp ) ; JSONString ] ;

    [ “user” ; Get ( AccountName ) ; JSONString ] ;

    [ “field” ; “Status” ; JSONString ] ;

    [ “from” ; $$old_Status ; JSONString ] ;

    [ “to” ; Status ; JSONString ]

  )

]

Set Field [ Table::AuditJSON ; List ( Table::AuditJSON ; $entry ) ]  // one JSON per line

 

 


 

2) A safe outbound “API outbox” (with retry)

What: Queue JSON payloads for external systems (ERP/CRM/shipping) with a status flag: Queued, Sent, Failed.
Why: Network hiccups happen; a queue prevents lost or duplicate updates.
How: Write payloads to an Outbox table; a server script (or Claris Connect) posts and updates status.

Set Variable [ $payload ;

  JSONSetElement ( “{}” ;

    [ “orderId” ; Orders::OrderID ; JSONString ] ;

    [ “total” ; Orders::Total ; JSONNumber ] ;

    [ “items” ; Orders::ItemsJSON ; JSONObject ]  // your own items JSON

  )

]

New Record/Request

Set Field [ Outbox::Endpoint ; “https://api.example.com/orders” ]

Set Field [ Outbox::Payload  ; $payload ]

Set Field [ Outbox::Status   ; “Queued” ]

 

 


 

3) Validate incoming JSON before it touches your fields

What: Confirm required keys and data types with JSON functions.
Why: Protects your schema; stops odd values at the door.
How: Use JSONListKeys and JSONGetElementType to check presence and types.

Set Variable [ $body ; $$IncomingJSON ]

If [ PatternCount ( ¶ & JSONListKeys ( $body ; “” ) & ¶ ; ¶ & “email” & ¶ ) = 0

  or JSONGetElementType ( $body ; “email” ) ≠ “string” ]

  Show Custom Dialog [ “Incoming JSON missing a valid email.” ]

  Exit Script

End If

 

 


 

4) Drive picklists and rules from JSON (no schema change)

What: Store business rules (allowed statuses, thresholds) in JSON so small changes don’t require schema edits.
Why: Faster updates; fewer trips through the relationship graph.
How: Keep rules in a Settings table, load to a global on first use.

// Settings::RulesJSON example: { “StatusOptions”: [“New”,”Packed”,”Shipped”] }

Set Variable [ $$rules    ; Settings::RulesJSON ]

Set Variable [ $$statuses ; JSONListValues ( $$rules ; “StatusOptions” ) ]

// Use $$statuses in a value list or custom UI

 

 


 

5) Hand a “view model” to a Web Viewer

What: Build a small JSON view model for a record and let HTML/JS render cards or charts.
Why: Clear separation: FileMaker gathers data; the viewer handles visuals.
How: Assemble JSON and pass it as a parameter or via a global field.

Set Variable [ $$vm ;

  JSONSetElement ( “{}” ;

    [ “customer” ; Customers::Name ; JSONString ] ;

    [ “balance”  ; Customers::AR_Balance ; JSONNumber ] ;

    [ “orders”   ; Customers::RecentOrdersJSON ; JSONObject ]  // prebuilt JSON

  )

]

// Web Viewer page reads $$vm and renders

 

 


 

6) A tidy JSON summary for BI (Power BI/Tableau)

What: Normalize your data once into JSON and expose it via an OData layout for BI tools.
Why: One shaping step in FileMaker keeps dashboards simple downstream.
How: Write a “staging” JSON per row in a BI_Staging table that your OData layout publishes.

Set Variable [ $row ;

  JSONSetElement ( “{}” ;

    [ “OrderID”   ; Orders::OrderID ; JSONString ] ;

    [ “ItemCount” ; ValueCount ( JSONListValues ( Orders::ItemsJSON ; “” ) ) ; JSONNumber ] ;

    [ “OrderDate” ; Orders::OrderDate ; JSONString ]

  )

]

Set Field [ BI_Staging::RowJSON ; $row ]   // include this field on the OData layout

 

 


 

How to try this (quick plan)

  1. Pick one use case above (audit trail or validation is a good start).

  2. Build a small script in a copy of your file; test with a few records.

  3. If it helps, add a Claris Studio form or a Claris Connect step to round out the flow.

  4. Share a short demo with your team and note the time saved or errors avoided.

Note on sample code
The snippets below are examples. You’ll need to adapt names and context to your solution before running them. In particular, update:

  • Layout names (e.g., Orders_list, Customers_edapi)

  • Table occurrences and field names (paths used in JSON and scripts)

  • Portal/table occurrence names for portalData and related writes

  • Privileges and triggers (who can run it, when it should fire)

  • Error handling (Get( LastError ), logging, retries)

  • Publishing context for BI (place fields on your OData layout)

Web Viewer handoff method (global field, script parameter, etc.)

 

 

How Claris Expanded “Execute FileMaker Data API” in 2024–2025

If you have not looked at the Execute FileMaker Data API script step (often shortened to eDAPI) in a while, it’s worth a revisit. Recent versions let you read and write records, including create, update, delete, and duplicate, by sending a small JSON request. You can do this without moving users around layouts and without calling the server’s web Data API. The step runs inside your file (hosted or local) and returns clear JSON that works well with web viewers, JavaScript, and external services. help.claris.com

 


 

What changed

  • Full CRUD + metadata. The action key supports read, metaData, create, update, delete, and duplicate. help.claris.com

  • Context-independent. Point to a layout in your JSON and eDAPI uses that context. No Go to Layout/Commit sequencing. help.claris.com

  • Local or hosted. It runs in your file and does not make a web service call to the Data API. help.claris.com

  • JSON in / JSON out. Pair with Get ( LastError ), Get ( LastErrorDetail ), and Get ( LastErrorLocation ) for diagnostics. help.claris.com

  • Concurrency-aware. Use modId on updates for optimistic concurrency. help.claris.com

  • Additional control. version supports v1, v2, vLatest; options.entrymode and options.prohibitmode let you follow or override validation/auto-enter rules when you need to. help.claris.com

 


 

Why teams find it useful

  • Shorter scripts. Many tasks become “build JSON → run one step.”

  • Fewer context issues. Read and write without leaving the user’s current layout.

  • Better interoperability. The JSON request/response makes it easy to work with web viewers, JavaScript, and Claris Connect.

  • Safer updates. modId helps avoid accidental overwrites when multiple users are editing.

 


 

Quick reference (keys you’ll use often)

  • action: read | metaData | create | update | delete | duplicate

  • layouts: target layout name (defines context)

  • tables: table occurrence name (for metaData)

  • query: array of find objects (standard FileMaker find operators)

  • recordId: internal ID for update/delete/duplicate

  • sort, offset, limit

  • fieldData: object of field:value pairs

  • portalData: object keyed by portal/TO name → array of related rows

  • modId: optimistic concurrency on update

  • layout.response: different layout for the response context (e.g., summary fields)

  • version: v1 | v2 | vLatest

  • options.entrymode: user | script

  • options.prohibitmode: user | script help.claris.com

 


 

Patterns and examples

Each example builds Request with JSONSetElement. Store the result in a variable and pretty-print with JSONFormatElements ( $$result ) while developing. Replace layout and field names with your own.

1) Read with a find and sort

// Returns last 100 paid orders from 2025, newest first

Execute FileMaker Data API [ Select ; Target: $$result ;

  JSONSetElement ( “{}” ;

    [ “layouts” ; “Orders_list” ; JSONString ] ;

    [ “query” ; “[ { \”Status\”:\”Paid\” , \”OrderDate\”:\”>=1/1/2025\” } ]” ; JSONArray ] ;

    [ “sort” ; “[ { \”fieldName\”:\”OrderDate\” , \”sortOrder\”:\”descend\” } ]” ; JSONArray ] ;

    [ “limit” ; 100 ; JSONNumber ]

  )

]

Set Variable [ $$result ; JSONFormatElements ( $$result ) ]

 

2) Create a record (temporarily allow a protected field)

Execute FileMaker Data API [ Select ; Target: $$result ;

  JSONSetElement ( “{}” ;

    [ “action” ; “create” ; JSONString ] ;

    [ “layouts” ; “Customers_edapi” ; JSONString ] ;

    [ “fieldData” ;

      “{ \”CustomerID\”:\”CUST-10027\” , \”Name\”:\”Acme Corp\” , \”Status\”:\”Active\” }” ;

      JSONObject

    ] ;

    [ “options” ; “{ \”prohibitmode\”:\”script\” , \”entrymode\”:\”user\” }” ; JSONObject ]

  )

]

 

3) Update with optimistic concurrency (modId)

Execute FileMaker Data API [ Select ; Target: $$result ;

  JSONSetElement ( “{}” ;

    [ “action” ; “update” ; JSONString ] ;

    [ “layouts” ; “Customers_edapi” ; JSONString ] ;

    [ “recordId” ; $recordId ; JSONString ] ;

    [ “modId” ; $expectedModId ; JSONString ] ;

    [ “fieldData” ; “{ \”Status\”:\”Inactive\” }” ; JSONObject ]

  )

]

If [ Get ( LastError ) = 0 ]

  # success

Else If [ Get ( LastError ) = 301 ]

  # record modified by another user; refetch and retry

End If

 

4) Create parent and related rows with portalData

Requires a layout with a portal where Allow creation of records is enabled for that table occurrence.

Execute FileMaker Data API [ Select ; Target: $$result ;

  JSONSetElement ( “{}” ;

    [ “action” ; “create” ; JSONString ] ;

    [ “layouts” ; “Orders_withLines_edapi” ; JSONString ] ;

    [ “fieldData” ; “{ \”CustomerID\”:\”CUST-10027\” , \”OrderDate\”:\”2/10/2025\” }” ; JSONObject ] ;

    [ “portalData” ;

      “{ \”Order_OrderLines\” : [

           { \”OrderLines::SKU\”:\”SKU-001\” , \”OrderLines::Qty\”:2 },

           { \”OrderLines::SKU\”:\”SKU-002\” , \”OrderLines::Qty\”:1 }

        ] }” ;

      JSONObject

    ]

  )

]

 

5) Duplicate and delete

// Duplicate

Execute FileMaker Data API [ Select ; Target: $$dup ;

  JSONSetElement ( “{}” ;

    [ “action” ; “duplicate” ; JSONString ] ;

    [ “layouts” ; “Orders_edapi” ; JSONString ] ;

    [ “recordId” ; $recordId ; JSONString ]

  )

]

 

// Delete

Execute FileMaker Data API [ Select ; Target: $$del ;

  JSONSetElement ( “{}” ;

    [ “action” ; “delete” ; JSONString ] ;

    [ “layouts” ; “Orders_edapi” ; JSONString ] ;

    [ “recordId” ; $recordId ; JSONString ]

  )

]

 

6) Discover structure with metaData

// List all table occurrences

Execute FileMaker Data API [ Select ; Target: $$tables ;

  JSONSetElement ( “{}” ;

    [ “action” ; “metaData” ; JSONString ] ;

    [ “tables” ; “” ; JSONString ]

  )

]

Set Variable [ $$tables ; JSONFormatElements ( $$tables ) ]

 

// List fields for a specific TO

Execute FileMaker Data API [ Select ; Target: $$fields ;

  JSONSetElement ( “{}” ;

    [ “action” ; “metaData” ; JSONString ] ;

    [ “tables” ; “Orders” ; JSONString ]

  )

]

Set Variable [ $$fields ; JSONFormatElements ( $$fields ) ]