# Bring Your Own AI Key

> Use your own OpenAI, Anthropic Claude, Google Gemini, Groq, or OpenRouter API key in Taskade automations. Your provider bills each model call, and each step uses a fixed step fee in Taskade credits.

- Source: https://www.taskade.com/learn/connect/byok-ai-integration
- Section: Connect
- Updated: 2026-10-26
- Index of all pages: https://www.taskade.com/learn/llms.txt

## Overview

Bring your own key means you paste an API key from an AI provider you already pay for. Taskade then uses that key to run AI steps in your automations. The provider bills you for each model call. Taskade bills a fixed step fee in credits for each step, and the fee is the same for every model.

> **TL;DR:** Connect your own OpenAI, Anthropic Claude, Google Gemini, Groq, or OpenRouter key to an [automation](https://www.taskade.com/learn/automation/automations-execution). Your provider bills each model call, and each step uses a fixed step fee in Taskade credits. OpenAI, Claude, and Gemini steps need Pro and up. Groq and OpenRouter steps need Business and up. See [Pricing](https://www.taskade.com/pricing).

```mermaid
flowchart TD
    A[Automation step]:::a --> D{Which AI step?}:::d
    D -->|Taskade AI| C[Taskade credits]:::c
    D -->|Your own key| P[Your provider account<br/>plus a fixed step fee]:::p
    classDef a fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
    classDef d fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
    classDef c fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
    classDef p fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```

## Pick the right path first

Taskade has two separate places to bring your own key, and they power different things. Check this table before you paste anything.

| | Provider steps (this page) | AI Model Keys |
| --- | --- | --- |
| Where the key goes | On the step, the first time you add that provider | The space's **Connections** page |
| What runs on it | That provider's own automation steps | Your AI agents and the built-in Taskade AI steps |
| Providers | OpenAI, Anthropic Claude, Google Gemini, Groq, OpenRouter | OpenAI, Anthropic, Google, and more. See [AI model key providers](https://www.taskade.com/models/providers) |
| Who can use it | Pro and up for OpenAI, Claude, and Gemini steps. Business and up for Groq and OpenRouter steps | Pro and up for OpenAI, Anthropic, and Google keys. Business and up for every other provider |

AppSumo and PitchGround lifetime plans also get the Pro-level steps and keys. An automation that you created before 2026-10-20 and kept on can run its provider steps for 30 more days on its current plan. After that, the plan rule in the table applies.

The rest of this page covers the first column. For the second, see [Bring Your Own AI Keys (BYOK)](https://www.taskade.com/learn/account/enterprise-byok).

## Connect a provider

Every provider connects the same way.

1. Open **Automations** in your workspace and click **Create**.
2. Add a trigger, then add a step and pick your provider. If the step shows a plan badge, your plan does not include that provider. Click the badge to see the plan that unlocks it.
3. Click **Connect**.
4. Paste your **API Key** into the single key field.
5. Save. Taskade checks the key against the provider before it saves, so a typo or a revoked key fails right there.

Your key is masked in the interface and stored encrypted. One connection covers the whole workspace, so every automation step that uses that provider reuses it.

> ⚠️ **Two OpenAI steps, one name.** You will see two OpenAI entries in the step list. The built-in Taskade AI one runs on your workspace credits with nothing to set up. The one on this page runs on your own key, bills your OpenAI account for the model, and uses the step fee in credits. The logos differ, and the description on the your-key version says it bills to your account.

## Where to get each key

| Provider | Get your key at | Key starts with |
| --- | --- | --- |
| OpenAI | [platform.openai.com/api-keys](https://platform.openai.com/api-keys) | `sk-` |
| Anthropic Claude | [console.anthropic.com/settings/keys](https://console.anthropic.com/settings/keys) | `sk-ant-` |
| Google Gemini | [aistudio.google.com/apikey](https://aistudio.google.com/apikey) | `AIza` |
| Groq | [console.groq.com/keys](https://console.groq.com/keys) | `gsk_` |
| OpenRouter | [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys) | `sk-or-` |

Sign in to the provider, create a key, copy it once, and paste it into Taskade. Most providers show a key only at the moment you create it.

## What each provider can do

| Provider | Steps available |
| --- | --- |
| OpenAI | Ask ChatGPT, Ask About an Image, Extract Structured Data, Generate Image |
| Anthropic Claude | Ask Claude, Ask About an Image, Extract Structured Data |
| Google Gemini | Ask Gemini, Ask About an Image, Extract Structured Data |
| Groq | Ask AI, Extract Structured Data |
| OpenRouter | Ask AI, Extract Structured Data |

Groq and OpenRouter cover the two text steps only. To ask about an image, pick OpenAI, Anthropic Claude, or Google Gemini. To generate an image, pick OpenAI.

One OpenRouter key reaches models from many providers at once. If you prefer one account instead of five, this is the shortest path.

### Ask the model

The Ask step sends a prompt and returns the reply as text. Type the model name yourself, so you are never limited to a list Taskade curates. Whatever your key can reach, you can use.

### Ask About an Image

Give the step an image and a question about it, and it returns a text answer. The image goes in as a public `https://` link, such as one from a form upload or an earlier step in the same automation.

The Claude and Gemini versions download the image themselves before asking the model about it. Two things follow from that. An address on a private network is refused, so the link has to be reachable from the open internet. And an oversized file is rejected with a message naming the size limit, rather than being quietly cut short. The OpenAI version hands the link straight to OpenAI, which fetches it.

### Extract Structured Data

Give the step a JSON schema and a piece of text, and it returns fields you can map into later steps.

| Field | What it holds |
| --- | --- |
| `data` | The extracted values |
| `raw` | The model's untouched reply |
| `parsed` | `true` only when the reply matches your schema, with required fields present and types correct |

`parsed` is stricter than "the model returned valid JSON", so it is safe to branch on. A schema the model cannot work with fails the step with a message instead of quietly returning something unusable.

### Generate Image

Available on OpenAI. Type your prompt and leave the model field empty to use the current default image model. The step always returns a hosted `url`, which later steps reference like any other link. Sometimes the model hands back raw image data instead of a link. Taskade stores the picture for you, so you never deal with the raw bytes.

OpenAI retired its older DALL-E image models. If you type one of those names in, the step says so up front instead of letting the attempt fail on your account.

## Credits and billing

| Step type | Who pays | Counts against Taskade credits |
| --- | --- | --- |
| Built-in Taskade AI steps | Taskade, from your plan | Yes, at the price of the model |
| Your own provider key | Your provider account, for the model call | Yes, one fixed step fee for each step |

Your provider sets the price of each model call, and you watch usage in the provider's own dashboard. Taskade adds no markup to that bill. For each step that runs on your key, Taskade bills one fixed step fee in credits. The fee is the same for every model. It comes from your monthly credits first, then from your credit packs. Lifetime plans pay no step fee.

Everything else in the automation, such as triggers, filters, and workspace actions, works as it always does.

## Common patterns

| You want to | Build this |
| --- | --- |
| Pay for the model on your own provider account | Swap the Taskade AI step for the same step on your own key |
| Use a model Taskade does not offer | Connect OpenRouter and type the model name |
| Pull fields out of an email or form | **Extract Structured Data**, then branch on `parsed` |
| Describe an uploaded screenshot | **Ask About an Image** with a public image link |
| Compare two providers on the same prompt | Two Ask steps side by side, then a step that reads both |

## Frequently Asked Questions

**Do these steps use my Taskade AI credits?**

Yes, but only the fixed step fee. Your provider bills the model call, and each step uses one fixed step fee in Taskade credits, the same for every model. A built-in Taskade AI step instead uses credits at the price of its model. Lifetime plans pay no step fee.

**Where is my API key stored?**

Encrypted, at the workspace level, and masked in the interface after you save it. Taskade uses it only to run the steps in your automations. Revoke it in your provider's dashboard at any time to cut access off immediately.

**Why are there two OpenAI steps?**

One runs on Taskade credits with nothing to set up. The other runs on your own OpenAI key, bills your OpenAI account for the model, and uses the fixed step fee in credits. Check the description on the step: the your-key version says it bills to your account.

**Which models can I use?**

Any model your key can reach. You type the model name into the step rather than picking from a fixed list, so a model your provider released yesterday works today.

**When is parsed true on Extract Structured Data?**

Only when the reply matches the schema you supplied, with required fields present and types correct. Valid JSON alone is not enough, which is what makes `parsed` safe to build a branch on.

**Can my AI agents use my own key too?**

Yes, on the second path described in [Pick the right path first](#pick-the-right-path-first). Store **AI Model Keys** on the space's **Connections** page. Your AI agents and the built-in Taskade AI steps then run on them. OpenAI, Anthropic, and Google keys work on Pro and up, plus AppSumo and PitchGround lifetime plans. Google connects as Google Vertex AI with a Google Cloud service account, or as a Google Gemini API key for agents. Every other provider needs Business and up. See [AI model key providers](https://www.taskade.com/models/providers) for the models that each key serves.

A key in a space serves the agents and automations of that space without per-agent setup. A key in the root workspace also serves the agents in its subspaces, and a subspace key of the same provider takes over from it. Automation steps use the keys of their own space only. Three things to watch. First, set an automation step to a specific model rather than **TSK-Auto**, or it keeps running on Taskade credits. An agent on Auto can use the key when Taskade picks a model from that provider. Second, the built-in Taskade AI steps offer **TSK-Auto** and the TSK tiers. Each TSK tier runs on a model from one provider, so a key serves only the tiers that run on its provider. Run one test step on each tier that you use, then check your provider dashboard. Third, a built-in AI step on your key also uses the fixed step fee in credits. Your plan includes agent steps on your key each month, and each agent step after that uses the same fee.

Taskade EVE can build on your key too, on Pro and up, when you pick a model under **Your keys** in its model menu. Your agents keep their [built-in toolkit](https://www.taskade.com/learn/agents/agent-tools) on either path. See [Bring Your Own AI Keys (BYOK)](https://www.taskade.com/learn/account/enterprise-byok) for the walkthrough.

## Related guides

- [Automations](https://www.taskade.com/learn/automation/automations-execution). Triggers, steps, filters, and run history.
- [AI Models and Credit Costs](https://www.taskade.com/learn/genesis/model-credits). What Taskade credits cover and how they are spent.
- [Bring Your Own AI Keys (BYOK)](https://www.taskade.com/learn/account/enterprise-byok). Workspace-level keys that your agents and built-in Taskade AI steps run on.
- [MCP Client Integration](https://www.taskade.com/learn/connect/mcp-client-integration). Call tools on a remote MCP server from an automation.
- [Custom AI Agents](https://www.taskade.com/learn/agents/custom-agents). Build agents with their own instructions, knowledge, and tools.
- [Integrations](https://www.taskade.com/integrations). The full catalog of triggers and actions.