In February 2026, nearly 3,000 Google API keys were accidentally exposed. Data breaches are always damaging, but a data breach due to an authenticated, active API key can be catastrophic. An active API key allows actors to access uploaded files, cached data, and charge LLM-usage to your account, as noted by cybersecurity researcher Joe Leon. To make matters even worse, these API keys were exposed via Google Gemini, which used the API keys as stand-ins for user IDs.

This example makes it clear that API keys have an even greater need to be secured in the age of AI. Most of us are already in the habit of thinking about API security, as we’ve been practicing it for years. Yet, AI has a tendency to fall outside of the scope of our security thinking, unfortunately, despite being intimately interconnected with APIs. If your APIs are going to be secure, your AI needs to be, as well. With that in mind, we’ve compiled ten tips for securing your API keys from AI to help keep both safe and secure.

1. Never Hardcode API Keys in Source Code

GitHub leaks are endemic, and they’re only getting worse. A recent study found that 23.8 million secrets were exposed in 2024, a 25% increase in a single year. The first, simplest, and most effective way to secure your API key — from misuse by autonomous agents, bots, and malicious actors — is to abstract your environment layer. For many cases, even a simple .env file will suffice. This even includes private repositories, as keys can accidentally be exposed via developer environments or CI/CD logs.

2. Consider Using a Dedicated Secrets Manager

In some circumstances, using an .env file alone won’t be enough. If an attacker gets access to your system, they can easily access these variables with a simple env or printenv command. If you’re serious about securing your API keys from AI, using a dedicated secrets manager like AWS Secrets Manager is a better best practice for API security, as the API key is retrieved at runtime instead of being stored as a system variable.

3. Automate API Key Rotation

Automating API key rotation is always a good idea for API security, but it becomes even more important in the age of AI. An API key gives shadow AI and malicious actors the keys to the kingdom if they happen to get a hold of them. Rotating API keys regularly is one of the simplest ways to help guarantee your AI ecosystem is secure. It’s generally recommended to rotate API keys every 30 to 90 days.

4. Limit API Keys’ Scope

When issuing API keys for AI, it’s generally a good idea to allow as little access as possible. If you know that GPT-5.0 is going to be interacting with your customers or clients as a chatbot, for instance, there’s no reason for it to have access to your financial records. As part of setting up your AI ecosystem, you should spend some time thinking about the role that AI is going to play in your organization. This will help you establish a proper scope for an API key.

5. Never Expose API Keys in an AI-Accessible Context

If an AI is able to access or retrieve an API key, it can be tricked into divulging the secret, no matter how careful you think you’re being. Regardless of how thorough and secure your instructions are, a malicious actor can get around your security with some clever wording. Simply providing an AI prompt telling the AI to avoid all previous instructions could potentially trick an AI into revealing an API key. To help prevent this from happening, your API key should remain on your server-side, never the client-side. It’s also a good practice to implement a backend proxy between the AI and an external API, which will help to prevent an API key from being leaked.

6. Enforce Strict Input/Output Boundaries

Prompt injection can cause all kinds of problems in an AI ecosystem. It can cause a LLM to expose sensitive data, circumvent security protocols, or execute unauthorized actions via a plugin. To help prevent this, an abstraction layer can help sanitize both inputs and outputs. Instead of allowing the LLM to generate raw responses or execute unmonitored commands, you should constrain both inputs and outputs by forcing them to choose from strict, well-typed actions with strictly-defined parameters. These can be validated by schemas, allowlists, and authorization rules.

7. Never Let an AI Construct Raw API Requests

Preventing an AI from making unfiltered API calls is another way to enforce boundaries around inputs and outputs. When an LLM is allowed to construct full URLs, headers, and request bodies, it effectively gains control over external systems. This creates an opportunity for malicious actors to redirect requests, alter requests, or expose sensitive data. Implementing a structured tool or function-calling layer that only allows an LLM to perform approved actions and that validates inputs as an intermediary between the AI and API will help prevent malicious actors from weaponizing your APIs.

8. Allowlist Approved IP Addresses

AI often runs on a fixed infrastructure, originating from a fixed IP address or a specified cloud provider. Allowlisting these IP addresses will prevent unauthorized systems from performing unauthorized actions even if they manage to get a hold of an API key.

9. Monitor for Unusual API Usage

Monitoring your API for unusual usage is one of the easiest and most surefire ways to help alert you that your API may be compromised. Traffic spikes or token requests and API calls coming from unusual regions are all common signs an API key has been leaked. Setting up an automated alert system to message you immediately via Slack, email, or SMS message will help keep any damage to a minimum if a data breach occurs.

10. Use a Trusted Execution Environment

If your AI is performing sensitive actions like working with financial data, a trusted execution environment (TEE) is one of the most secure ways to ensure API security. TEEs ensure that API keys are only ever exposed in plaintext in the TEE sandbox. When an AI needs to make an API call, the secret is pulled from storage in an encrypted state and passed into the TEE. This protected area is even invisible to the rest of the system, making it impervious to the most intense system attacks.

Securing Your API Keys In The AI Age

The prevalence of AI is forcing a major shift in how we think about API security. We’re already accustomed to thinking in terms of zero-trust architecture, API monitoring, and regular API key rotation are all almost automatic for most of us. AI still falls outside of these usual accommodations, however, largely due to the technology still being so new.

To help make sure that your APIs remain secure, even in the age of AI, start by storing and accessing environment variables properly while enforcing strict access control via strict scoping and proper allowlisting. Enforcing strict formatting also prevents an AI from improper API usage, which further prevents an LLM from executing dangerous actions or revealing sensitive data. Following these tips for securing your API keys from an AI will let you move forward into the AI-driven future with confidence.