What is API Key?
A unique identifier token passed with API requests to authenticate the client and track usage against a specific account.
An API key is a unique, secret identifier issued to a client that is included in API requests to authenticate the caller and associate the request with a specific account. API keys serve as a simple but effective authentication mechanism for server-to-server integrations, providing identity verification, usage tracking, rate limit enforcement, and billing attribution without the complexity of OAuth flows or session management.
API keys are typically long, randomly generated strings that are practically impossible to guess. They are passed in API requests through HTTP headers (the most secure method), query parameters (simpler but less secure as they may appear in server logs and browser history), or request bodies. The API server validates the key against its database of issued keys, identifies the associated account, and processes the request with the permissions and limits configured for that account.
The lifecycle of an API key includes generation, distribution, active use, rotation, and eventual revocation. Best practices require that keys be generated with sufficient entropy (at least 128 bits of randomness), distributed through secure channels, stored in encrypted form on both server and client, rotated periodically, and revoked immediately if compromised. Most API providers support multiple active keys per account to enable zero-downtime rotation.
API keys differ from OAuth tokens in several important respects. API keys are typically long-lived and do not expire automatically, while OAuth tokens are short-lived. API keys grant account-level access, while OAuth tokens can be scoped to specific permissions. API keys are appropriate for server-to-server communication where the client is trusted, while OAuth is appropriate when a third-party application accesses data on behalf of a user.
Why It Matters
API keys are the most common authentication mechanism for developer-facing APIs because they balance security with simplicity. A developer can go from obtaining an API key to making a first successful API call in minutes, with no need to implement OAuth flows, manage token refreshes, or configure authorization servers. This low barrier to entry accelerates integration timelines and reduces the friction of developer onboarding.
For API providers, API keys enable essential operational capabilities. Each key uniquely identifies a client, enabling per-client rate limiting that ensures fair resource allocation. Usage data associated with each key enables accurate billing for metered pricing models. And the ability to revoke individual keys provides a mechanism for cutting off access to compromised or abusive clients without affecting other users.
Security considerations around API keys are significant. Unlike OAuth tokens, API keys do not expire automatically and provide full account-level access. If an API key is leaked, whether through accidental inclusion in source code, exposure in server logs, or compromise of the client's infrastructure, it remains valid until explicitly revoked. This creates a window of vulnerability that can be exploited by unauthorized parties.
Proper API key management requires organizational discipline. Keys should never be committed to source code repositories, embedded in client-side code, or transmitted over unencrypted channels. They should be stored in environment variables, secrets management services, or encrypted configuration files. Regular rotation reduces the window of exposure if a key is compromised without detection.
How Signa Helps
Each Signa organization can create several named API keys, so each environment or service can have its own key and be revoked on its own. Keys in one organization share its data and credits, so naming a key "development" creates no boundary: true isolation of test traffic needs a separate organization, as in the example below. Keys use the format sig_ followed by 48 hex characters, are shown once at creation, and should be copied into a secrets manager straight away.
Each key carries one or more scopes, such as trademarks:read for search and retrieval or portfolios:manage for watches and portfolios, so a key can be limited to the access it needs. Credits and rate limits apply per organization, shared by all its keys.
Signa supports zero-downtime rotation: rotating a key issues a new one and keeps the old key working for a 24-hour grace period while services switch over. Keys can also be revoked at once. Signa's dashboard shows API usage and a log of the requests that reached the API, so account owners can review activity and rotate or revoke a key they suspect has leaked.
Keys are for server-side use only. Never ship one in browser or mobile code; call Signa from your backend instead.
Example
A trademark analytics company runs its data pipeline in three environments: development, staging and production. It creates a separate Signa API key for each, and a separate test organization for development so test traffic draws on its own credits.
Each key is stored in the company's secrets manager and injected as an environment variable into the matching deployment, and no key appears in source code, configuration files or logs. The production key carries only the scopes the pipeline needs, and the security policy requires quarterly rotation, which the 24-hour grace period makes possible without downtime.
When a developer accidentally commits the development key to a public repository, the team revokes it immediately and creates a replacement. Because it belonged to the separate test organization, the exposure never touched production data or the production credit balance.