Make.com modules

Integrations / Make.com

Connect Make.com to your AccessEXL-enabled Excel workbooks and use your existing spreadsheet models in automated business processes.

AccessEXL lets Make read configured workbook outputs and tables, update approved inputs, run calculations, and write records to configured Excel tables without giving scenario users direct access to the underlying workbook.

Important: The fields available in Make are controlled by the AccessEXL configuration in the connected workbook. If the workbook configuration changes, refresh the schema in Make before continuing.

Getting started

Before building a scenario, you need:

• an AccessEXL-enabled workbook;
• a valid AccessEXL API key for that workbook; and
• the AccessEXL app available in Make.

Connect AccessEXL to Make

1. Add an AccessEXL module to your Make scenario.
2. In Connection, select an existing AccessEXL connection or click Add.
3. Enter the API key for the workbook you want to use.
4. Save the connection.

An AccessEXL connection is associated with the workbook available through that API key. If your scenario needs to work with a different workbook, select or create the appropriate connection.

Which module should I use?

For most automation involving an Excel calculation model, start with Run a Scenario. For normal row-by-row table writing, use Add Table Row.

Workbook modules

Get Workbook Schema

Use this module when: you need to inspect the AccessEXL configuration available to your Make scenario.

Get Workbook Schema retrieves the workbook's configured inputs, outputs and tables. It does not change the workbook.

Configuration

Select the appropriate Connection. No other configuration is required.

Returned information

The module returns information including:

• workbook label;
• writable inputs;
• readable outputs;
• configured table/block definitions; and
• a list of configured tables.

The exact contents depend on the workbook's AccessEXL configuration.

Typical uses

Use Get Workbook Schema when you need to:

• inspect what a workbook makes available through AccessEXL;
• obtain a configured table name for a later module;
• troubleshoot a workbook configuration; or
• build a more advanced dynamic Make scenario.

Tip: Most simple scenarios do not need Get Workbook Schema as a separate step. Modules such as Add Table Row, Update Inputs and Run a Scenario already use the workbook schema to create their user-friendly fields.

Refresh Workbook Schema

Use this module when: the AccessEXL configuration inside the workbook has changed and you need AccessEXL to reread it.

Refresh Workbook Schema forces a non-billable refresh of the workbook configuration and returns the current schema.

Configuration

Select the appropriate Connection. No additional fields are required.

When to use it

Run this module after changes such as:

• adding or removing configured inputs or outputs;
• changing display names or descriptions;
• adding or changing configured tables;
• changing table columns; or
• changing validation/configuration metadata.

You normally do not need to refresh the schema during every scenario run.

Run a Scenario

Use this module when: you want to provide inputs to an Excel model, recalculate it and receive its configured outputs in a single operation.

This is usually the simplest AccessEXL module for using an Excel model as part of an automated business process.

How it works

When you select a connection, AccessEXL reads the workbook schema and automatically displays the workbook's configured writable inputs.

For example, a financial model might expose:

• Business Case
• Staffing Ramp up Speed
• Loan Amount
• Loan Interest rate
• Weighted Average Cost of Capital

The labels and help text come from the workbook's AccessEXL configuration.

Configuration

1. Select the workbook Connection.
2. Map or enter values for the inputs you want to change.
3. Save the module.

When the scenario runs, AccessEXL:

1. writes the supplied values to the configured inputs;
2. recalculates the workbook; and
3. returns the configured outputs.

Example

A form could collect assumptions for a financial model:

Form submission
      ↓
AccessEXL - Run a Scenario
      ↓
Email / CRM / report

The form values are mapped to the workbook assumptions. Excel performs the model calculations, and the resulting outputs can then be mapped into later Make modules.

When to choose Run a Scenario

Choose this instead of separate Update Inputs and Get Outputs modules when you need both actions as one logical calculation.

Update Inputs

Use this module when: you want to write configured input values to the workbook and recalculate it.

Like Run a Scenario, Update Inputs dynamically displays the inputs configured in the selected workbook.

Configuration

1. Select the workbook Connection.
2. AccessEXL displays the configured writable fields.
3. Enter fixed values or map values from previous Make modules.
4. Save the module.

Only fields deliberately exposed as writable through the AccessEXL workbook configuration are available.

Example

CRM opportunity updated
      ↓
AccessEXL - Update Inputs

A scenario could update assumptions in a workbook when values change elsewhere.

Update Inputs vs Run a Scenario

Use Update Inputs when updating/recalculating the workbook is the required action and you do not need all configured outputs returned as part of that same operation.

Use Run a Scenario when you want to send inputs and immediately use the calculated outputs later in the same Make workflow.

Get Outputs

Use this module when: you want to retrieve the current values of all configured workbook output ranges.

Configuration

Select the workbook Connection. No other fields are required.

Example

Scheduler
   ↓
AccessEXL - Get Outputs
   ↓
Email / database / dashboard

This is useful when inputs have already been updated, or when you simply want to read the workbook's current calculated results.

Only ranges configured as readable outputs are returned.

Table modules

AccessEXL provides three table modules:

• Get Table Rows for reading;
• Add Table Row for the normal row-by-row writing experience; and
• Write Multiple Table Rows for bulk array-based writing.

Get Table Rows

Use this module when: you want to read the current rows from an Excel table configured in AccessEXL.

Configuration

1. Select the workbook Connection.
2. Enter or map the exact configured Table name.
3. Save the module.

The table name is the configured TableName shown by Get Workbook Schema.

Example

AccessEXL - Get Workbook Schema
      ↓
AccessEXL - Get Table Rows
      ↓
Filter / CRM / database / email

The module returns the configured columns and current rows from the selected table.

Important: Use the configured table name, not a display description or the name of an unrelated readable range.

Add Table Row

Recommended for most table-writing scenarios.

Use Add Table Row when each incoming Make bundle represents one row that should be added to Excel.

Why this is the easiest option

After you select a connection:

1. AccessEXL loads the workbook's configured tables.
2. You select the required table from the Table name dropdown.
3. AccessEXL automatically displays the configured columns for that table.
4. You map values directly into those fields.

You do not need to construct JSON or manually define the table structure.

Example: Google Sheets to Excel

Suppose a Google Sheet contains:

• Project Name
• Project Manager
• Estimated Construction Cost
• Percentage Complete

Your scenario can simply be:

Google Sheets - Search Rows
      ↓
AccessEXL - Add Table Row

Select tblProjects, then map:

Google Sheets Search Rows produces one bundle for each source row. Make therefore runs Add Table Row once for each bundle.

Numbers from other apps

Some Make apps return numbers as text. If AccessEXL expects a numeric column, convert the value before sending it.

For example:

parseNumber(Estimated Construction Cost)

and:

parseNumber(Percentage Complete)

This ensures AccessEXL receives JSON numbers rather than text values.

When to use Add Table Row

Use it when:

• records arrive individually from another Make module;
• you want simple field-by-field mapping;
• ease of configuration is more important than batching; or
• you are building a normal Make scenario where each bundle represents one record.

Write Multiple Table Rows

Use this module for bulk operations where the rows are already available as an array.

Write Multiple Table Rows sends several rows to a configured Excel table in a single AccessEXL request.

Configuration

The module requires:

Table name
Enter the exact configured table name.

Rows
Use Add row to enter rows individually, or map an array containing one object for each row to be written.

For example, the array conceptually looks like:

[
  {
    "Project Name": "Project A",
    "Project Manager": "John Smith",
    "Estimated Construction Cost": 50000000,
    "Percentage Complete": 57
  },
  {
    "Project Name": "Project B",
    "Project Manager": "Jane Godfrey",
    "Estimated Construction Cost": 12000000,
    "Percentage Complete": 66
  }
]

The property names must match the configured Excel table columns.

Example: Google Sheets bulk write

A typical scenario is:

Google Sheets - Search Rows
      ↓
Array Aggregator
      ↓
AccessEXL - Write Multiple Table Rows

Configure the Array Aggregator with:

• Source module: Google Sheets - Search Rows
• Target module: AccessEXL - Write Multiple Table Rows
• Target structure: Rows

Map the required table columns from the source records. Convert text-formatted numeric values with parseNumber() where necessary.

Then map the aggregator's resulting array into the Rows field of Write Multiple Table Rows.

Add Table Row vs Write Multiple Table Rows

Important: Do not use both modules on the same records unless you deliberately want to write the records twice. If Search Rows feeds Add Table Row and those same rows are later aggregated and sent to Write Multiple Table Rows, you will create duplicate writes.

Advanced module

Make an API Call

Use this module when: you need an AccessEXL API operation that is not covered by one of the dedicated modules.

For most scenarios, use the dedicated AccessEXL modules instead. Make an API Call is intended for advanced users.

Fields

Method
Choose GET or POST.

Relative path
Enter the AccessEXL API path without the host or a leading slash.

Examples:

schema

or:

blocks/MyTable

Requests remain restricted to the configured AccessEXL host.

Query string
Provide query parameters as JSON when required.

Request body
For POST requests, provide the JSON request body.

Example: read the schema

Method: GET
Relative path: schema
Query string: {}
Request body: {}

Authentication is handled through the selected AccessEXL connection.

Tip: If a dedicated AccessEXL Make module exists for what you are trying to do, use it. Dedicated modules provide a simpler and safer configuration experience.

Working with dynamic fields

One of the main advantages of the AccessEXL Make app is that several modules adapt to the selected workbook.

Workbook input fields

Update Inputs and Run a Scenario read the workbook configuration and display the configured writable inputs automatically.

This means one workbook might show:

Business Case
Staffing Ramp up Speed
Loan Amount
Loan Interest rate
Weighted Average Cost of Capital

while another workbook can expose a completely different set of fields.

Display names and descriptions configured in AccessEXL are also shown in Make, making scenarios easier to understand.

Table fields

Add Table Row goes one step further:

1. select a table;
2. AccessEXL reads that table's configured columns; and
3. Make displays those columns as individual mappable fields.

If the workbook configuration changes, refresh the module/schema so Make can retrieve the current fields.

Common AccessEXL + Make patterns

1. Use an Excel model as a calculation engine

Form / CRM / database
      ↓
Run a Scenario
      ↓
Email / CRM / database

Use an existing, governed Excel model to perform calculations inside an automated process.

2. Add records from another system to Excel

Google Sheets / CRM / form
      ↓
Add Table Row

Best when the source app produces one Make bundle per record.

3. Bulk-write records to Excel

Source records
      ↓
Array Aggregator
      ↓
Write Multiple Table Rows

Best when you deliberately want to collect records into an array and submit them together.

4. Update assumptions without retrieving outputs immediately

Business system
      ↓
Update Inputs

5. Read calculated results on a schedule

Make Scheduler
      ↓
Get Outputs
      ↓
Email / Teams / database

6. Read an Excel table into another business process

Get Table Rows
      ↓
Filter / Iterator / business application

Troubleshooting

My workbook fields do not appear

Check that the inputs or table columns are correctly configured in the workbook's AccessEXL configuration.

If the configuration was recently changed:

1. run Refresh Workbook Schema;
2. reopen or refresh the relevant Make module; and
3. confirm that the latest fields are displayed.

Update Inputs or Run a Scenario shows no input fields

The selected workbook may not contain any configured writable inputs.

Confirm that the correct AccessEXL connection has been selected and that the workbook exposes writable ranges through its AccessEXL configuration.

I cannot find my table in Add Table Row

Confirm that:

• you selected the correct workbook connection;
• the table is configured for AccessEXL;
• the current schema includes the table; and
• the workbook schema has been refreshed after recent configuration changes.

Use Get Workbook Schema if you need to inspect the configured tables.

Get Table Rows says the table cannot be found

Make sure Table name contains the configured table name, not a display description or named range.

For example:

tblProjects

Numeric values fail or are treated as text

Some Make source modules return values that look numeric but are actually strings.

Use Make's parseNumber() function before mapping these values into numeric AccessEXL fields.

Example:

parseNumber(Loan Amount)

Write Multiple Table Rows writes blank rows

Inspect the output of the upstream Array Aggregator. Each item must contain the expected table fields and values.

Do not assume that selecting a target structure automatically maps the source fields. Confirm that the aggregator is actually constructing populated row objects.

Records were written twice

Check that the same records are not being sent through both:

• Add Table Row, and
• Write Multiple Table Rows.

Choose one writing method for a given set of records.

My scenario uses an old workbook structure

After changing the AccessEXL configuration, use Refresh Workbook Schema and refresh/reopen modules that depend on dynamic fields.

You may need to review existing mappings if fields have been renamed or removed.

Authentication fails

Confirm that:

• the selected AccessEXL connection contains a valid API key;
• the API key belongs to the intended workbook/account; and
• the connection has not been replaced or revoked.

Recommended module choices

For the simplest AccessEXL experience:

Calculating with an Excel model: use Run a Scenario.

Updating model assumptions only: use Update Inputs.

Reading model results: use Get Outputs.

Adding records to an Excel table: use Add Table Row.

Bulk-writing an existing array: use Write Multiple Table Rows.

Reading Excel table data: use Get Table Rows.

Inspecting configuration: use Get Workbook Schema.

After changing workbook configuration: use Refresh Workbook Schema.

For advanced/custom API operations: use Make an API Call.

Quick reference

Need help?

If a scenario is not behaving as expected, start by checking:

1. the selected AccessEXL connection;
2. the workbook's AccessEXL configuration;
3. Get Workbook Schema to confirm what is exposed; and
4. Refresh Workbook Schema if the workbook configuration has recently changed.

For table writes, use Add Table Row unless you specifically need to submit an array of multiple rows in a single request.

For workbook configuration, see the API Reference setup guide. For request and response details, see the API Reference. Still stuck? Ask the Help assistant.