Using Data Inputs [Beta]

Beta Feature: Data inputs are currently in beta. Contact your Technical Account Manager for access.

A Data input lets the person generating a presentation hand Matik a whole piece of content, by uploading a file or pasting it in, instead of picking from a list or typing a single value. Matik then feeds that content into your Dynamic Content the same way it would feed in a query result.

Use it to bring in content that cannot reach Matik through a connected data source:

Output from your AI assistant, such as a query or an analysis it ran against a data source that is connected to the assistant but not to Matik.
An export from a system that cannot be connected to Matik, such as a CSV from an internal tool.
Content that changes with every generation, such as call notes, a transcript, or a brief.

For background on inputs in general, see the Inputs Overview.

How It Works

Setting up a Data input takes three steps:

Create the input from a sample. You give Matik an example of the content the input will receive. Matik reads the fields it contains and uses that to describe the input and, optionally, to check what people supply later.
Reference the input from Dynamic Content. How the content is used is decided by the Dynamic Content that references it. An Insights Dynamic Content reads the content as text. A Static Table Dynamic Content turns it into a table with the columns you choose.
Supply the content at generation. The person generating uploads a file or pastes content into the input. An AI agent can pass the content in directly through Matik's API or MCP server.

Note: A Data input does not reshape the content itself. It always carries the content exactly as supplied. Each Dynamic Content that references it decides what to do with it, so two Dynamic Contents can present the same upload in two different ways.

Creating a Data Input

Create one the same way you create any input: from the Inputs page, from the Dynamic Content editor by typing &: followed by a name, or from the input side panel. In the Input Format selector, choose Data.

Sample Content

Upload or paste an example of what the input will receive. Matik reads the sample and does three things:

Works out the format. Content that parses as JSON is read as JSON. Content with a header row and consistent columns is read as CSV. Anything else is read as plain text.
Lists the fields it contains. For a CSV, the fields are the header row. For JSON, Matik finds the repeating records in the document (a top-level list, or the longest list of objects inside it) and lists their fields, including one level of nesting. Fields appear under Expected Fields with a type and an example value from the sample.
Drafts a description. Matik writes a one-sentence Display Description from the sample if that field is empty. It never overwrites a description you wrote.

The sample is also the input's default value. If the person generating supplies nothing, Matik uses the sample. Set a realistic sample for that reason: it is what the end user sees pre-filled on the form, and what the presentation uses if they leave it in place.

A plain-text sample, such as a transcript, declares no fields. That is expected. Matik notes that the sample reads as plain text and leaves Expected Fields empty.

Note: Prose whose lines all have the same number of commas, such as a transcript with one speaker turn per line, can be mistaken for a one-column table. Matik then lists the sample's first line as a field and turns on Require specific fields in the content. If you see that, turn the toggle off. The input still accepts the content; it only stops checking it.

Entry Validation Settings

These settings control what Matik accepts at generation. Both are optional. With neither set, the input accepts any content.

Required file format: Any, CSV, or JSON. With Any, Matik works out the format of each upload from its content. Pinning the format filters the file picker to that extension and makes Matik refuse content at generation that is not in that format, whether it was uploaded or pasted. There is no plain-text option: an input that should only receive prose does not need a format.
Require specific fields in the content: When this is on, Matik checks each upload against the Expected Fields list and refuses to generate when the content does not match. Uploading a sample turns this on and fills the list for you. You can mark fields as required or optional, add or remove fields, and click Read fields from sample to rebuild the list from the current sample. Fields cannot be renamed here, because the names are what Dynamic Content columns look up in the content.

Note: If you require fields but leave the format on Any, Matik warns that it will do its best to read each upload before checking it. Requiring CSV or JSON removes the guesswork.

AI Instructions

Under the display fields, AI Instructions is a plain-text note for an AI that fills in this input, such as an agent generating through Matik's MCP server. Describe what the value should be, for example One row per account we renewed this quarter, most recent first. End users never see it. The Display Description is what they read.

When an AI agent reads a template's inputs through Matik's MCP server or API, it receives the AI Instructions and the Expected Fields for each Data input, so it can produce content in the shape the input expects.

After saving

An input on its own does nothing until a Dynamic Content references it. After you save a Data input that nothing uses yet, Matik shows a banner offering to create one. Click Create table content and Matik creates a Static Table Dynamic Content named after the input (for example account_data_table), whose body is the input reference, and opens it so you can choose the columns. If you want the content analyzed by a model rather than placed on a slide as a table, skip the banner and reference the input from an Insights Dynamic Content instead.

Using a Data Input in Dynamic Content

Reference a Data input the way you reference any other: type &: followed by the input's name wherever the content should go. What happens next depends on the Dynamic Content.

In an Insights, Claude, Snowflake Cortex, or Narrative Dynamic Content

The content is inserted into the prompt as text, exactly as supplied. This is the natural fit for content you want a model to read and analyze: a transcript, a report, a JSON scorecard. For example, in an Insights Dynamic Content prompt:

Read the following sales call transcript and list the three most important follow-up actions for the account team, with a one-line rationale for each: &:call_transcript

Whatever the person pastes or uploads for call_transcript replaces &:call_transcript before the prompt runs. A CSV or JSON upload is inserted as the raw CSV or JSON text, which a model reads without trouble.

As a table on a slide: Static Table Dynamic Content

To put the content on a slide as a table, create a Static Table Dynamic Content whose body is nothing but the input reference: &:account_data. When the body is a bare reference to a Data input, a Columns to pull from this file input card appears under it. The columns you declare here are what the table shows.

Use the input's fields: Proposes one column per field the input expects, in the order they appear in the sample. Reorder, rename, and delete from there.
Column Name: The column header on the slide. By default Matik looks this name up in the content, so it matches a CSV header or a JSON key, ignoring case.
Path (optional): A jq expression for a value that is not a top-level field, such as one nested inside each record. The expression runs against the whole document and must produce one value per row, for example .signals[] | .score or .[] | .summary.region. (jq is a standard query language for JSON.)

With no columns declared, the content is inserted as text instead of a table.

Matik reads the records from the content, then builds the table from your columns:

A CSV's header row names the fields, and each following row is a record.
A JSON list of objects is one record per object. A lone JSON object is a single record, so the table has one row.
A JSON object that wraps a list of records, like the scorecard in Example 3 below, needs a Path on each column to reach into the list. Use the input's fields fills those paths in for you.
A column whose name is not in the content produces blank cells rather than failing the generation.

Note: The columns belong to the Dynamic Content, not to the input. Two Static Table Dynamic Contents can reference the same input and show different columns from the same upload. The input only states what the content must contain.

Tagging individual values

A Static Dynamic Content with declared columns exposes those columns as sub-content, so you can tag one value inline with dot notation. Sub-content expects a single row, so use this when the content is one record, or when your Path expressions isolate one. For the scorecard in Example 3, a second Static Dynamic Content named scorecard_summary with the columns overall_score (Path .summary.overall_score) and tier (Path .summary.tier) produces one row, and {{scorecard_summary.overall_score}} tags the score into a headline. Column names with spaces cannot be tagged this way. See Sub-Content.

In other Dynamic Content

Google Sheets, Excel, and REST API Dynamic Content accept a Data input and insert its content as text wherever the reference appears. SQL and other query-based data sources do not accept Data inputs: Matik blocks the save and tells you which input to remove. See Troubleshooting.

Filling In the Input at Generation Time

When someone generates a presentation that uses a Data input, the field on the form offers two tabs:

Upload File: Choose a file from their computer. If the input requires a format, the picker filters to that extension and the field says CSV files only or JSON files only. A dropped file in the wrong format is refused with a message.
Paste Content: Paste the content straight into a text box. Handy for output an AI tool has produced. Pasted content is not checked for format until generation.

If the input has a sample, the field arrives pre-filled with it, and the person can generate without supplying anything or replace it with their own content. After generation, the file an end user supplied can be downloaded from the presentation's inputs view.

If the content fails the input's rules, generation stops and the form shows which input was refused and why. See Troubleshooting.

From an AI agent or the API

Through Matik's API, or an agent connected to Matik's MCP server, the content is passed as the input's value as a plain string when creating the presentation. No upload step is needed. For content that is large or inconvenient to inline, the API also offers an upload endpoint that returns a reference to submit as the value instead. When the agent lists the template's inputs first, each Data input comes with its AI Instructions and Expected Fields.

Examples

Example 1: Turn a call transcript into recommendations

You have an account-review template with an Insights Dynamic Content that writes recommended next steps. You create a Data input named call_transcript and paste a past transcript as the sample. A transcript has no fields to require, so check that Require specific fields in the content is off: if Matik read the transcript's first line as a field, every later transcript would be refused. In the Insights prompt you reference the input with &:call_transcript, like the prompt shown above.

After a customer call, the rep pastes the new transcript into the Paste Content tab. Matik feeds it to the prompt, which reads the whole conversation and writes the follow-up actions onto the slide. The source material is different every time and lives nowhere in your data warehouse.

Example 2: Put an exported account list on the slide

You maintain a territory review template with a table of the rep's top accounts. The list comes out of a CRM export that is not connected to Matik, and it has fifteen columns when the slide has room for three.

You create a Data input named account_data, upload a past export as the sample, and set Required file format to CSV. Matik lists the fifteen header names under Expected Fields. You click Create table content on the banner, and on the new Static Table Dynamic Content you click Use the input's fields, then delete all but account_name, arr, and renewal_date.

At generation, the rep uploads the latest export. Matik checks that it is a CSV with the expected fields, keeps the three columns you declared, and renders the table on the slide. The export can reorder its columns or gain new ones without breaking the slide. The rep never has to clean up the file first.

Note: Every arr cell in the sample was filled, so Matik requires arr to be filled in every row of an upload. If a column can be blank in real exports, include a blank cell for it in the sample, or remove that field from Expected Fields.

Example 3: Bring in an AI assistant's analysis as both a narrative and a scorecard

Your team's AI assistant is connected to a product-usage database that Matik is not. You ask it to produce an account health scorecard as JSON, with an overall score and a list of usage signals:

{
  "summary": { "overall_score": 68, "tier": "Growth" },
  "signals": [
    { "name": "New Records Created", "value": 210, "trend": "up" },
    { "name": "Reports Run", "value": 540, "trend": "flat" },
    { "name": "Contacts Added", "value": 18, "trend": "down" }
  ]
}

You create a Data input named health_scorecard, paste that JSON as the sample, and set Required file format to JSON. Matik lists summary and signals under Expected Fields, with name, value, and trend under signals. The sample's numbers were whole, so Matik typed overall_score and value as whole numbers. If the assistant might return decimals, change those fields to number. You add AI Instructions so the assistant knows what to produce: An account health scorecard with an overall score and one signal per product area.

Then you use the same input twice:

An Insights Dynamic Content reads the whole object and writes a short analysis: Summarize this account's health in four sentences and call out the two signals most at risk: &:health_scorecard
A Static Table Dynamic Content with the body &:health_scorecard renders the signals as a table on the slide. Click Use the input's fields and Matik proposes name, value, and trend, each with the path that reaches into the signals list (for example .signals[] | .value).

Because the assistant is connected to Matik's MCP server, the whole flow runs without leaving the assistant: it reads the input's instructions, produces the JSON, and starts the generation with it as the value for health_scorecard. If the JSON ever comes back without the expected fields, Matik refuses the generation and says which field is missing instead of producing an empty table.

Best Practices

Start from a realistic sample: Everything else is read from it: the field list, the draft description, the default value. A sample with the same fields as real uploads means the Expected Fields match on the first try.
Make the sample as messy as real uploads: Matik reads the rules from the sample. A field that is filled in every sample row must be filled in every upload, and a whole number stays a whole number. Include a blank cell or a decimal in the sample where real content can have one, or adjust the field under Expected Fields.
Pin the format when you require fields: Requiring CSV or JSON tells Matik exactly how to read each upload before checking it, so a file that happens to look like prose is not misread.
Leave validation off for prose: A transcript or a brief has no fields to require. Let the input accept any content and send it to an Insights Dynamic Content.
Declare columns on the Dynamic Content, not in the file: Naming the columns you want protects your slide from an export that carries extra columns or reorders them. Only a renamed header matters.
Write AI Instructions when an agent will fill the input: One sentence on what the value should contain, and in what shape, saves the agent from guessing.
Always include a header row in a CSV: The first row names the fields. Without it, your first row of real data is treated as the header.

Limitations

Supported Dynamic Content only: Data inputs work in Insights, Claude, Snowflake Cortex, Narrative, Static, Google Sheets, Excel, and REST API Dynamic Content. SQL and other query-based data sources reject them at save.
Tables need a bare reference: A Static Dynamic Content only renders a table, and only exposes sub-content, when its body is nothing but &:input_name. Any surrounding prose and Matik treats the whole body as text.
One table per content: A Data input is read as one set of records. A list nested inside each record is shown as its JSON text in a cell, not expanded into a second table.
Types come from the sample: Marking a field optional only allows it to be missing. A field that is present but blank, or a decimal where the sample had a whole number, still fails the check unless the sample showed that too or you change the field's type.
Field lists are capped: Matik proposes at most 25 fields from a sample, two levels deep. Add anything beyond that by hand.
Prompts receive the content as-is: A large upload is inserted into an Insights prompt without being condensed. Keep it within what the prompt can hold.
A broken column degrades, it does not fail: If a Path expression cannot run against the content, that Dynamic Content renders the content as text rather than stopping the generation. Check the expression against the sample.

Troubleshooting

Message	What it means	What to do
Input "name" must be a CSV file. Input "name" must be a JSON file.	The input requires a format, and the content supplied at generation is not in it. Renaming a file's extension does not change its content.	Supply content in the required format, or set Required file format to Any on the input.
Input "name" does not match its expected format: field: reason	The input requires specific fields, and the content is missing one or has a value of the wrong type. The message names each field that failed.	Fix the content, or edit Expected Fields on the input to match what is actually supplied. Mark a field optional if it is not always present.
Input "name" does not match its expected format: /0: 'first line of the sample' is a required property	The input holds prose, and Matik read the sample as a one-column table, so it now requires the sample's first line in every upload.	Open the input and turn off Require specific fields in the content.
This input only accepts CSV files. This input only accepts JSON files.	A file dropped onto the input has the wrong extension for the required format.	Upload a file with the matching extension, or paste the content instead.
File input 'name' can't be used with this data source. File inputs are only supported for Google Sheets, Excel, REST, and prompt-based (Insights, Cortex, Narrative) data sources.	The input is referenced from a Dynamic Content whose data source cannot accept one, most often a SQL query. Matik blocks the save.	Remove the reference, or move it to an Insights or Static Dynamic Content.
Could not read file input "name".	Testing a Dynamic Content could not read the file supplied for the input.	Re-upload or paste the content in the test form and run again.
Invalid JSON sample: reason	The sample starts like JSON but does not parse.	Fix the JSON and upload the sample again. A JSON validator will point at the problem.
This sample reads as plain text, so it declares no fields to require.	The sample is prose, or a CSV too small or irregular to read as a table.	Expected for prose. For a table, make sure the sample has a header row and at least two data rows, or pin Required file format to CSV.
Matik couldn't find named values in this sample. Add fields manually below.	The sample parsed, but Matik could not find repeating records with named fields in it.	Add the fields by hand under Expected Fields, or supply a sample shaped like a list of records.