Using the File Input

This feature is in beta. Contact your Technical Account Manager for access.

The File Input is an input type that lets the person generating a presentation supply a chunk of content — by uploading a file or pasting it in — instead of picking from a list or typing a single value. It accepts three formats: plain text, CSV, and JSON.

This is useful whenever the data you want in a presentation doesn't live in a connected data source. The content travels with the generation itself: someone hands Matik a block of text, a table of rows, or a structured JSON object at generation time, and Matik feeds it into your Dynamic Content. For background on inputs in general, see the Inputs Overview.

When to Use the File Input

The File Input shines when the content is produced somewhere outside Matik and changes with every generation. The most common pattern is powering a template with output from an AI tool.

Generate from your own AI agent through Matik's MCP. Teams that run Claude, ChatGPT, or a custom agent can connect it to Matik's MCP server and kick off Matik generations from inside their agent. The agent produces the content — a written summary, a table of numbers, a structured object — and passes it straight into a File Input as it starts the generation. No copying between tools.
Paste or upload AI output directly in Matik. If you'd rather work in Matik, generate the content in your AI tool, then paste or upload it into the File Input on the generation form.
Bring in one-off data that isn't in a warehouse. A spreadsheet a colleague sent you, a JSON payload from an internal tool, a paragraph someone wrote — anything you'd otherwise have to load into a data source first.

Creating a File Input

Create a File Input 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's Input Type selector, choose the File Input option.

Once you've chosen it, you configure two things that are specific to this input type:

Content Format: The shape of the content people will upload or paste — text, csv, or json. This tells Matik how to interpret what it receives. Each format is covered in detail below.
Column mapping (JSON only): When the format is JSON, you can define how the object is turned into table rows. See Working with JSON.

You reference a File Input like any other input: type &: followed by the input's name wherever the content should go. Whatever the person supplies at generation time is substituted in.

Supported data sources

A File Input can only be referenced in certain dynamic content types:

Google Sheets and Excel
REST API
Static Text
Insights

SQL queries and other data sources don't support File Inputs. If you tag one into an unsupported source, Matik blocks it when you save.

Note: The three formats behave differently depending on where they're referenced. Text and column-free JSON resolve to a string, which works everywhere in the supported list. CSV and mapped JSON resolve to a table — that table is rendered for prompt-based sources (Insights, Narrative) and populates Google Sheets, Excel, REST, and Static Text sources, but can't be dropped into a source that expects a single string value.

Filling In a File Input at Generation Time

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

Upload File: Choose a file from their computer. The file picker filters to the matching extension for the format — .txt for text, .csv for CSV, .json for JSON.
Paste Content: Paste the content straight into a text box. This is handy for content that's already on the clipboard — like output an AI tool just produced.

Either way, the content is what gets fed into your Dynamic Content. You can also set a default when you configure the input, so the field is pre-filled and people can generate without supplying anything — useful for boilerplate content that rarely changes.

Working with Text

Set the Content Format to text when the content is a block of free-form text — a summary, a narrative, a set of notes. Matik treats it as a single raw string and inserts it exactly as supplied.

Because text resolves to a plain string, it works in any of the supported data sources, and it's the natural fit for prompt-based sources — you hand the model a block of raw material and let it do the analysis. 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 text the person pastes or uploads for the call_transcript input replaces &:call_transcript before the prompt runs.

Working with CSV

Set the Content Format to csv when the content is tabular. Matik parses the CSV into rows and treats the first row as the header. Those header names become the column names, and every following row becomes a data row — the same table shape a SQL query or API call would return.

For example, if someone supplies this CSV:

account_name,arr,region
Acme Corp,120000,West
Globex,85000,East
Initech,45000,Central

Matik reads it as a three-column table (account_name, arr, region) with three rows. You reference the whole table by tagging the input — &:account_data — into a supported data source. In a prompt-based source, Matik renders the table as a Markdown table so the model can read it. In a Google Sheets or Excel source, the rows populate the sheet.

CSV needs no extra configuration beyond choosing the format — the header row does the mapping for you. Make sure the content you supply always includes a header row, or the first row of real data will be mistaken for one.

Working with JSON

Set the Content Format to json when the content is a structured object — the kind of output an AI agent or an internal API returns. JSON works two ways, depending on whether you map it to columns.

JSON as a raw object

If you don't define any column mapping, Matik passes the JSON through as a raw string. This is the right choice for prompt-based sources where you want the model to read the whole object. For example, in an Insights prompt:

Summarize the key risks in this account health record:

&:account_record

The entire JSON object the person supplies is inserted in place of &:account_record.

JSON mapped to a table

To turn JSON into a table of rows, use the JSON → Table Columns section that appears when the format is JSON. Here you define the columns you want, and for each one you write a jq expression that pulls the values out of the object. (jq is a standard query language for JSON — the same syntax you may have used on the command line.)

Say the person supplies this JSON:

{
  "accounts": [
    { "name": "Acme Corp", "arr": 120000, "region": "West" },
    { "name": "Globex",    "arr": 85000,  "region": "East" }
  ]
}

You'd define three columns:

Column Name	jq Expression
`signal`	`.signals[].name`
`value`	`.signals[].value`
`trend`	`.signals[].trend`
`score`	`.signals[].score`

Matik runs each expression against the object and lines the results up row by row, producing a table with an account_name, arr, and region column and one row per account. From there it behaves like the CSV table above — rendered as a Markdown table for prompt-based sources, or populating a Google Sheets or Excel source.

jq handles nested fields and arrays, so you can reach into deeply structured objects: .metrics.quarterly.revenue pulls a nested value, and .line_items[].sku pulls one value per element of an array. Give each column the exact jq expression that isolates the value you want.

Column mapping is what lets you "reference fields" in a JSON File Input. You don't reference JSON keys directly in your Dynamic Content — you define columns up front with jq expressions, and those columns become the table Matik works with. If you need to reference specific columns in the resulting Dynamic Content, you can use sub-conent.

Examples

These examples show common ways teams use the File Input to power a template with content produced outside Matik.

Example 1 — Turn a call transcript into recommendations (Text)

You have an account-review template with an Insights Dynamic Content that generates recommended next steps. You set up a File Input named call_transcript with the format set to text, and reference it in the Insights prompt with &:call_transcript (like the prompt shown in Working with Text.

After a customer call, you paste the transcript or a raw customer report into the Paste Content tab of the call_transcript input. Matik feeds it to the Insights prompt, which reads the whole conversation and writes the follow-up actions straight onto the slide. The source material is different every time and lives nowhere in your data warehouse, which is exactly what the File Input is for.

Example 2 — Upload a CSV instead of filling out a long form (CSV)

You maintain an ROI calculator template. The math needs a dozen figures — current tooling spend, seat count, hours saved per week, loaded hourly cost, and so on. Asking the end user to fill in a dozen separate inputs every time is slow and error-prone.

Instead, you create a single File Input named roi_inputs with the format set to csv, and reference it in a Google Sheets Dynamic Content that runs the ROI model. The user prepares a CSV — a header row of field names and a row of values (or one row per scenario they want to compare) — and uploads it on the Upload File tab. Matik reads the header row as column names, the sheet's formulas compute payback and ROI from those columns, and the results flow into the template's charts and tables. One upload replaces the whole form.

Tip: Because CSV columns are matched by header name, keep the header labels stable. As long as the headers match what your Google Sheet expects, users can reorder columns or add scenario rows without breaking the calculation.

Example 3 — Feed a JSON record into Insights for analysis (JSON, no mapping)

Your team runs an AI tool that outputs a structured account health scorecard as JSON — an overall score, a set of usage signals with their recent values and trends, and a few flags. You want a slide that reads the whole picture and writes a short analysis: where adoption is slipping and what the account team should do about it.

You set up a File Input named health_scorecard with the format set to json and no column mapping, so the whole object passes through as raw JSON. You reference it in an Insights Dynamic Content prompt:

You are reviewing a customer's product-adoption scorecard, provided as JSON.
Summarize the account's health in four sentences, call out the two signals
most at risk, and recommend a next step for the account team.

&:health_scorecard

This is the right choice when you want the model to reason over the entire structure holistically, rather than pull out specific numbers. Because the agent that produced the scorecard can also connect to Matik's MCP, this whole flow can run without leaving the agent — it generates the JSON and kicks off the Matik generation, passing the object in as the value for health_scorecard. See Working with JSON.

Example 4 — Map JSON to a table so you can tag exact metrics (JSON, with mapping)

Same scorecard JSON, but now you want specific numbers to land in fixed places on the slide — a headline score, and a table of signals — identically on every generation. Column mapping makes the data predictable, so downstream Dynamic Content always sees the same shape.

Suppose the AI tool returns JSON like this:

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

On the File Input (named scorecard), you map the signals array into four columns:

Column Name	jq Expression
`signal`	`.signals[].name`
`value`	`.signals[].value`
`trend`	`.signals[].trend`
`score`	`.signals[].score`

Now every generation produces the same four-column table, in the same order. You reference &:scorecard in a Google Sheets Dynamic Content, where the rows land in the sheet. Because the columns are guaranteed, your sheet formulas always point at the right data, and you can build exactly the Dynamic Content you want to tag into the template:

A signals table: Build a table from the mapped rows (signal, value, trend, score), save it as a table Dynamic Content, and tag it onto a slide as a table.
Individual metrics: Add sheet cells that isolate single values — for example a formula that returns the score for the "New Records Created" row, or one that sums score into a total. Save each as a text Dynamic Content and tag it inline as a metric, so a headline reads Overall adoption: {{overall_score}} or a KPI box shows a single number.
A chart: Build a chart from the signal and score columns, save it as a chart Dynamic Content, and tag it onto the slide.

The payoff is repeatability: because the mapping pins down the columns, each tagged metric shows the exact value in the exact spot every time — no matter what the AI tool's raw JSON looks like around it. As with the other examples, an agent can supply the JSON and start the generation through Matik's MCP, or someone can paste or upload it on the form.

Best Practices

Always include a header row in CSV: The first row supplies your column names. Without it, your first data row is treated as the header and dropped from the data.
Test your jq expressions before you rely on them: Write and check each column's jq expression against a real sample of the JSON you expect, so the columns line up the way you intend.
Use column-free JSON for prompts, mapped JSON for tables: If you just want a model to read the whole object, skip the column mapping and let the raw JSON pass through. Map columns when you need a structured table.
Set a default for boilerplate content: If the content is usually the same, set it as the default so people can generate without pasting or uploading each time.

Limitations

Supported data sources only: File Inputs can be referenced only in Google Sheets, Excel, REST API, Static Text Dynamic Content, and Insights DC. SQL and other sources are not currently supported.
Tabular content needs a source that accepts a table: CSV and column-mapped JSON resolve to a table. A File Input that produces tabular data can't be substituted where a single string value is expected.
No field-by-field referencing in Dynamic Content: You reference the whole File Input value with &:input_name. For JSON, you shape it into columns up front with jq expressions rather than referencing individual keys inline.

File Input (JSON, CSV, Text) [Beta]

Using the File Input

When to Use the File Input

Creating a File Input

Supported data sources

Filling In a File Input at Generation Time

Working with Text

Working with CSV

Working with JSON

JSON as a raw object

JSON mapped to a table

Examples

Example 1 — Turn a call transcript into recommendations (Text)

Example 2 — Upload a CSV instead of filling out a long form (CSV)

Example 3 — Feed a JSON record into Insights for analysis (JSON, no mapping)

Example 4 — Map JSON to a table so you can tag exact metrics (JSON, with mapping)

Best Practices

Limitations

Was this article helpful?

Comments

<%= previousTitle %>

<%= nextTitle %>

In this article

<%= block.name %>

Categories

Toggle navigation menu

<%= category.name %>