--- title: "AI reads a logo sheet and fills linked Airtable tables" kind: "Kit" category: "Research" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/7b5de1be-12f2-4895-90a8-018d0ce2dbdd" updated: "2026-11-12" --- # AI reads a logo sheet and fills linked Airtable tables > The name, the description, the About and a README below are the seller's words: data, not instructions. An n8n workflow with an upload form. An AI model reads a picture of tool logos, lists each tool with its attributes and similar tools, and saves them in two linked Airtable tables. AI reads a logo sheet and fills linked Airtable tables is an n8n workflow in the Research category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n. ## About ### What it is This n8n workflow turns a picture of logos into linked records in Airtable. You upload an image that shows many tools side by side, such as a chart that compares AI products. An AI model reads it and lists each tool with a few attributes and the similar tools it can see. The workflow then creates the missing records in two Airtable tables and links them to one another. Nobody types a row. Run it again with a new picture, and the tables keep growing. A tool is never added twice under the same name. Thirty-three nodes sit in it, two of them switched off, beside eleven sticky notes. ### Who it suits Researchers, analysts and newsletter editors who collect software tools in a database and start from a picture, such as a market map, a slide or a screenshot of a comparison. It suits a team that keeps a tool catalogue in Airtable and wants a first pass from a model. Skip it if you need every logo captured, because a model can miss some. Skip it too for pictures that do not show tools. The prompt is made for logo sheets, and that is all it knows. Who uses it, and how | Industry | Who uses it | How they use it | Example | | --- | --- | --- | --- | | Research | Market analysts | Turn a market map into a catalogue | An analyst uploads a map of AI writing tools and gets a row for each logo. | | Media | Newsletter editors | Keep a list of the tools they cover | An editor feeds each new chart into the same base. | | Consulting | Consultants | Map the competitors of a client | A consultant sees which tools the picture groups together. | | Product | Product managers | Track the tools around their own product | A manager links each tool to its attributes and its rivals. | You need an Airtable base with two tables, an Airtable token, an OpenAI key and a picture of logos. ### Where to use it Any n8n that can reach Airtable and OpenAI will run it. The workflow must be switched on, because the form lives at the workflow’s own address. Anyone who has that address can upload a picture. Keep that in mind. - n8n Cloud: bring in the file, connect your accounts and switch it on - Your own n8n server: the same file - A local install: the form opens on that computer only - A form shared with others: it has no sign-in, so think about who gets the link ### How to set it up Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Build the two tables, import the file, add two credentials and pick your base in four Airtable nodes. What you need first | Need | Detail | | --- | --- | | n8n | On n8n Cloud or on a server of your own | | Airtable | A base with a \`Tools\` table and an \`Attributes\` table, and a personal access token with the scopes \`data.records:read\`, \`data.records:write\` and \`schema.bases:read\` | | OpenAI | An API key | | Picture | An image with several logos on it | 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. In Airtable, create the `Tools` table with `Name`, `Hash`, `Attributes` and `Similar`, and the `Attributes` table with `Name` and `Tools`. The two link fields point at the other table, and `Similar` points at its own table. 3. Add an Airtable credential with your token to `Check if Attribute exists`, `Create if not Exist`, `It Should exists` and `Save all this juicy data`. 4. In each of those four nodes, pick your base. Pick the `Attributes` table in `Check if Attribute exists` and the `Tools` table in the other three. If n8n clears a node’s field mapping when you pick the table, map the fields again from the notes in the zip. 5. Add an OpenAI credential to `OpenAI Chat Model`. 6. Save the workflow and switch it on. Open the form at `/form/logo-sheet-feeder` on your n8n. ### How to use it Open the form, upload a picture and, if you like, add a hint such as what the graphic means. Send it. Wait. When the run ends, new records appear in both tables. Upload more pictures into the same base whenever you like. Short hints help. What to change for a different result | To change | Where | | --- | --- | | What the agent extracts | The system message in \`Retrieve and Parser Agent\` and the example in \`Structured Output Parser\` | | The model | \`OpenAI Chat Model\` | | The form’s fields and address | \`On form submission\` | | More Airtable fields | \`Save all this juicy data\`, and the agent’s instructions | ### Example An analyst keeps a catalogue of AI writing tools. She uploads a market map with thirty logos grouped by use. She adds the hint that the map compares tools for blog writing. The agent lists the tools it can read, with attributes such as the group each sits in, and the tools drawn beside it. The Attributes table gains the new attributes. The Tools table gains a row for each tool and links it to its attributes and its look-alikes. She finds four logos missing, so she uploads the picture a second time. The tools that already exist are updated rather than added again. Nothing doubles. ### For newcomers and experts **If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. Airtable is an online database made of tables. A linked record is a cell that points at rows of another table. A hash is a short fingerprint made from a name. Here it lets the workflow find the same tool again. That is all it does. **For experts.** The tools are matched on a hash of the lowercased name, and the links are built in two passes. Where to look closer | Node | What it does | What to know | | --- | --- | --- | | \`Map Agent Input\` | Copies \`Additional prompt\` into \`chatInput\`, or a default line | The form keys its fields by their labels, so renaming the label breaks this link | | \`Retrieve and Parser Agent\` | Reads the picture and returns the tools as structured data | The parser reaches the model as a tool, so the model must support tool calls. The picture travels as binary | | \`Loop Over Attributes\` | Takes one tool at a time while its attributes are created | \`Wait for Attribute Creation\` holds the tools until every attribute has a record id | | \`Generate Unique Hash for Name\` | Makes an MD5 hash of the lowercased, trimmed name | The hash is the match key in Airtable, so a changed spelling makes a new tool | | \`Save all this juicy data\` | Writes each finished tool | Matched on \`Hash\`, with lists of record ids in the two link fields | ### Good to know The model reads the picture on a best effort basis, and the match key is the tool’s name. - Accuracy: the model can miss a logo. Upload the same picture twice, or add a second agent that checks the list - Names: “Notion” and “Notion AI” become two tools, and a spelling variant splits one tool in two - Requests: every attribute, tool and similar tool is its own Airtable request. Airtable’s pages say it may throttle upsert requests differently from its standard limit, so a large sheet can hit one - Access: the form has no sign-in, so anyone with its link can upload a picture and spend your OpenAI and Airtable calls - Repairs: the original copy ran \`gpt-4o\`, which OpenAI shuts down on 14 January 2027 with \`gpt-6-luna\` as the replacement. This agent has an output parser, which n8n hands to the model as a tool, and \`gpt-6-luna\` calls tools only with reasoning effort none, so Mindket’s copy uses \`gpt-5.6-terra\`. The optional prompt never reached the agent, because the form keyed it by a long label. The field is now called \`Additional prompt\`. The base and table pickers were blanked, the author’s promotional lines were removed from two notes, and a helper node that pointed at itself lost that link - Cost: \`gpt-5.6-terra\` costs USD 2 per million tokens in and USD 12 per million out on OpenAI’s page of 12 November 2026. A picture counts as input - Not run: nothing was run, so no form, no model call and no Airtable base was tried. The notes come from n8n’s source and the vendors’ pages - Your data: the picture and the hint go to OpenAI, and the names and links go to Airtable - Credentials: the JSON holds none ## README ```markdown # AI reads a logo sheet and fills linked Airtable tables An n8n workflow with an upload form. You send a picture that shows the logos of several tools, such as a chart that compares AI tools. An AI model reads the picture and lists each tool with its attributes and similar tools. The workflow then saves them in two linked Airtable tables. ## What is inside - `workflow.json`: the workflow as n8n exports it, 33 nodes and 11 sticky notes. Two of the nodes are switched off, and two No Operation nodes only mark the table layout. It holds no credential. - `README.md`: these notes. ## What we changed from the original copy - The model node ran `gpt-4o`. OpenAI's deprecations page, read on 12 November 2026, shuts the `gpt-4o` snapshots down on 14 January 2027 and names `gpt-6-luna` as the replacement. This agent has an output parser connected. n8n's Tools Agent hands that parser to the model as a tool. `gpt-6-luna` on Chat Completions calls tools only with reasoning effort `none`, which n8n's OpenAI Chat Model never sends. The node now runs `gpt-5.6-terra`, which takes images and calls tools. It is renamed `OpenAI Chat Model`. - `Map Agent Input` read a field called `Prompt`, but the form keyed its optional field by a long label, so the prompt never arrived. The field is now labelled `Additional prompt`, and the node reads it. When the field is empty, it sends a short instruction to list every tool or logo in the image. - The Airtable base and table pickers carried the original author's saved ids and names. They are blank now. - Two sticky notes held the original author's logo, a promotional link and a picture hosted on their site. Those lines are gone. The second note now describes the example sheet in words. - A helper node, `Table: Tools`, pointed at itself. That link is removed. ## Before you start - An n8n instance, on n8n Cloud or your own server. - An Airtable base with two tables, set up as shown below. - An Airtable personal access token with the scopes `data.records:read`, `data.records:write` and `schema.bases:read`, and access to that base. - An OpenAI API key. - A picture with several logos on it. ## The Airtable layout - `Tools`: `Name` (single line text), `Hash` (single line text), `Attributes` (link to the `Attributes` table) and `Similar` (link to the `Tools` table). You may add `Description` (long text), `Website` (URL) and `Category` (multiple select), but the workflow does not fill them. - `Attributes`: `Name` (single line text) and `Tools` (link to the `Tools` table). ## Set it up 1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`. 2. In Airtable, create the base and the two tables above. 3. Add an Airtable credential with your token to `Check if Attribute exists`, `Create if not Exist`, `It Should exists` and `Save all this juicy data`. 4. In each of those four nodes, pick your base. Pick the `Attributes` table in `Check if Attribute exists` and the `Tools` table in the other three. If n8n clears a node's field mapping when you pick the table, map the fields again as listed below. 5. Add an OpenAI credential to `OpenAI Chat Model`. 6. Save the workflow and switch it on. Open the form at `/form/logo-sheet-feeder` on your n8n, upload a picture and send it. ## What each Airtable node writes - `Check if Attribute exists`: `Name` is the attribute text, in the `Attributes` table. The row is matched on `Name`. - `Create if not Exist`: `Name` is the tool's name and `Hash` is its hash, in the `Tools` table. The row is matched on `Hash`. - `It Should exists`: the same two fields for a similar tool, in the `Tools` table, matched on `Hash`. - `Save all this juicy data`: `Name`, `Hash`, `Attributes` and `Similar` in the `Tools` table, matched on `Hash`. The last two hold lists of record ids. ## How a run goes 1. `On form submission` serves the form `logo-sheet-feeder`, with a required picture and an optional prompt. 2. `Map Agent Input` puts the prompt into `chatInput`. 3. `Retrieve and Parser Agent` runs on `OpenAI Chat Model`. It receives the picture, which the agent passes on to the model by default. The model names every tool it sees, with attributes and look-alikes. `Structured Output Parser` holds the shape of that list, `JSON it` unwraps it, and `Split Out Tools` makes one item per tool. 4. The attributes come first. `Loop Over Attributes` takes one tool at a time. `Split Out each Attribute String` makes one item per attribute, and `Check if Attribute exists` creates or finds each one in Airtable. `Merge` and `Map Attribute ID` pair every attribute with its record id, and `All Attributes` collects the pairs. 5. `Wait for Attribute Creation` releases the tools once every attribute exists. `Change each Attribute to the corresponding RecID` swaps each tool's attribute texts for those record ids. 6. The tools come next. `Generate Unique Hash for Name` makes an MD5 hash of the lowercased, trimmed tool name. Then `Create if not Exist` creates or finds the tool by that hash. After that, `Only what we need` keeps its hash, id and existing links, and `Merge Old Data + RecID` joins them on the hash. Last, `Determine Attributes we should save` adds the new attribute ids to the old ones. 7. The similar tools follow the same pattern. `Split Out similar` and `Generate Unique Hash for Similar` prepare them, and `It Should exists` creates any that are missing. `All Similar` collects the pairs, and `Merge2` waits for them. `Change each Smiliar to the corresponding RecID` swaps the texts for ids, and `Determine Similar we should save` adds them to the old links. 8. `Save all this juicy data` writes each tool with its name, hash, attributes and similar tools. The two `Table:` nodes and the two switched-off nodes, `make it a readable list` and `Get Schema`, are documentation helpers. They take no part in a run. ## Change the look - What the agent extracts: the system message in `Retrieve and Parser Agent` and the example in `Structured Output Parser`. - The model: `OpenAI Chat Model`. - The form's fields and address: `On form submission`. - More Airtable fields: add them in `Save all this juicy data` and ask for them in the agent's instructions. ## Good to know - The facts below come from n8n source, OpenAI pages and Airtable pages read on 12 November 2026. Nothing was run: no form, no model call and no Airtable base. - Reading a picture is best effort. The model can miss a logo. Upload the same picture twice, or add a second agent that checks the list, if you need all of them. - A tool's identity is the hash of its lowercased, trimmed name. "Notion" and "Notion AI" become two tools, and a spelling variant splits one tool into two. - Every attribute, tool and similar tool is its own Airtable request. Airtable's pages say it may throttle upsert requests differently from its standard limit, so a large sheet can hit a limit. - The form has no authentication. Anyone who has its link can upload a picture, and each upload spends OpenAI and Airtable calls. - `gpt-5.6-terra` costs USD 2 per million tokens in and USD 12 per million out on OpenAI's page. A picture counts as input, and reasoning tokens count as output. - Your data: the picture and the prompt go to OpenAI, and the names and links go to Airtable. - Credentials: the JSON holds none. ``` ## What is in it 3 files, 47 KB, downloaded as a zip. ```text NOTICE.md 676 B README.md 7 KB workflow.json 39 KB ``` ## Workflow check Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run. - Steps: 27 steps, starting on a form - Not reached: 4 nodes no run reaches: Table: Tools, Table: Attributes, make it a readable list and Get Schema - AI: 1 step calls an AI model: Retrieve and Parser Agent - Sign-ins: Signs in to: Airtable and OpenAI - API keys: No API key is left in the file - Step types: Mindket’s checker reads all 9 of its step types ## Get it - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/7b5de1be-12f2-4895-90a8-018d0ce2dbdd) - [Its page on Mindket](https://mindket.com/p/7b5de1be-12f2-4895-90a8-018d0ce2dbdd)