Resources · n8n integration

n8n Embeddings Google Gemini nodeConfigure Embeddings Google Gemini in n8n.

The n8n Embeddings Google Gemini node is a sub-node, so it never runs on its own. It hangs off the Embeddings port of a vector store and turns text into vectors, the numeric form AI uses to compare meaning. One parameter to set, Model, and one Google credential behind it.

Try the Embeddings Google Gemini node on n8nSee the 1 parameters

Verified Trustpilot reviews · AI, automation & growth agency

Why automate

What does the n8n Embeddings Google Gemini node do?

It generates embeddings for a given text using a Google Gemini model. An embedding is a vector, a long list of numbers that places a piece of text somewhere in meaning space, so a database can later find the passages closest to a question. This node produces those vectors and hands them to whatever root node it is wired to.

The node has no main input and no run button of its own. In n8n's AI model, a root node such as an AI Agent, a chain or a vector store receives the workflow items, and sub-nodes clip onto its ports: a chat model here, a memory there, an embeddings provider on the Embeddings port. This one only fills that last slot.

First scenario, indexing. A document arrives, a text splitter cuts it into passages, a Default Data Loader passes them through, and the vector store writes each passage with the vector this node returned. Second scenario, retrieval. The same vector store, in query mode, embeds the incoming question with the exact same Model value and compares it against what was stored. Third scenario, an agent that answers from your own documentation: the Vector Store Question Answer Tool sits on the agent's tool port, and the store behind it leans on these embeddings.

Two details decide whether the setup works. The Model value has to match between indexing and querying, because vectors produced by different models are not comparable. And the vectors already written to a store do not update themselves when you change that value later, so a switch means reindexing.

When to reach for something else: if the rest of your stack already runs on another provider, the OpenAI embeddings sub-node fills the same port and keeps the credential count down. This node is the right pick when the chat side of the workflow is already a Google Gemini Chat Model, since one Google credential then covers both. Google bills its own API calls under its own terms, n8n adds nothing on top.

Three published templates show the shape end to end: a RAG chatbot over Google Drive files with a Pinecone Vector Store (2753), a documentation bot on a Supabase Vector Store (5993), and the same idea on a Simple Vector Store (6137). If you want the honest take on the platform before committing, there is the n8n review, and the n8n training for the hands-on route.

Connect

How do you connect it to Google?

  1. 01

    Create the Google AI credential

    Open Credentials in n8n and create the Google AI credential the node's documentation points to. A credential in n8n is a saved set of secrets, stored once and referenced by name, so nothing sensitive ever sits in the workflow itself. Create it before you open the node and the dropdown will already have it.

  2. 02

    Paste the API key from Google

    The key comes from the Google side, not from n8n. Paste it into the credential form and save. Because this node only calls the embeddings endpoint, the same key can also serve a Google Gemini Chat Model in the same workflow: one credential, several sub-nodes, no duplicate secrets to rotate later.

  3. 03

    Select the credential in the node

    Drop the node on the canvas, pick the credential in the selector at the top of the panel, then choose the Model. Attach the node to the Embeddings port of the root node and the connection is done. The same credential is reusable in every other workflow on the instance, on n8n Cloud as well as on a self-hosted install.

Connections

Where does this node plug in?

A port is a labelled socket on a root node, and each type of sub-node fits exactly one of them. This node has no input port at all, only an output that fits the Embeddings socket.

Output (what it plugs into)

  • Embeddingsai_embedding
01EmbeddingsThis is the only connection the node has. The output of type ai_embedding is what a root node reads whenever it needs text turned into vectors, both when writing to the store and when searching it.

This is the only connection the node has. The output of type ai_embedding is what a root node reads whenever it needs text turned into vectors, both when writing to the store and when searching it.

Key parameters

  • Required: a vector store cannot store or search anything without an embeddings sub-node on this port.
Use cases
wire the node to a store in insert mode to index a corpus, then to that same store in query mode so the agent can search it. Templates 2753, 5993 and 6137 each do exactly that, with a different store sitting behind the port.
Parameters

What is there to configure?

The Embeddings Google Gemini node has one parameter. For each one: the node as you configure it in n8n, what the parameter changes, and our field notes.

01

Model

modelName

What you see in n8n

Notes & use cases

The node exposes a single parameter: the model that will generate the embeddings. It is a dropdown, not a free text field, and it is not marked required, so the node carries a value out of the box and runs without you touching anything.

Key parameters

  • Model: picks which Google Gemini model produces the vectors. Google's model list, linked from the parameter description, is the reference for what is available on your key.
Use cases
leave it alone for a first RAG pipeline, and only revisit it when you have a reason to. Changing it on a store that already holds vectors invalidates them, since the old and new vectors no longer sit in the same space.
Need help

Need help automating Embeddings Google Gemini with n8n?

A person reads every message.

FAQ

Questions people ask next

01Is the Embeddings Google Gemini node included in n8n?
Yes. It ships inside n8n's AI package, so there is nothing to install and nothing extra to pay on the n8n side, on n8n Cloud and on a self-hosted instance alike. The Community Edition under the Sustainable Use licence includes it. What does have a cost is the Google side: the provider bills its own API calls under its own terms, and every passage you index or question you embed is a call. That is worth knowing before you point the node at a large corpus, because indexing is where the volume is, not querying.
02What do you need to run the n8n Embeddings Google Gemini node?
A Google AI credential and a root node to attach to. The credential holds the API key and is created once in n8n, then reused everywhere. The root node matters just as much: this is a sub-node, it has no main input, and on its own it does nothing at all. Drop it on a canvas with nothing wired to its Embeddings output and no execution will ever reach it. In practice you build the vector store first, then hang this node off its Embeddings port.
03What are the limits of this node?
It does one job, and version 1 of the node exposes exactly one parameter, the Model. There is no batch size setting here, no dimension override, no retry option to tune. Everything else about how the vectors are written or searched belongs to the root node, so that is where you look when something needs adjusting. The other real constraint is consistency: vectors from different models cannot be compared, so switching the Model value means reindexing whatever is already in the store.
04What is the minimum to get started with it?
Four pieces, no more. A text splitter to cut documents into passages, a Default Data Loader to feed them, a vector store, and this node on the store's Embeddings port. Start with a Simple Vector Store as template 6137 does, because it needs no external account and you can throw the whole thing away and start over. Once the retrieval quality looks right, swap in a Pinecone Vector Store or a Supabase Vector Store and keep the rest of the workflow exactly as it is.
05n8n or Make for a RAG pipeline?
It depends on where you want the data and how you want to pay. n8n can be self-hosted, so the documents you embed and the vectors you store stay on infrastructure you control, and the same workflow runs identically on n8n Cloud. Make is hosted only and bills per operation, which is predictable but adds up fast on an indexing run that fires thousands of calls. The other difference is the node model itself: the root node plus sub-node structure, with a dedicated socket for embeddings, has no direct equivalent.
Hack'celeration Lab

Get our weekly integration tips.

No spam. Unsubscribe anytime.

Same platform

Other docs you might need on this stack.

Browse all integrations