> For the complete documentation index, see [llms.txt](https://infinitode-docs.gitbook.io/documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://infinitode-docs.gitbook.io/documentation/faqs/questions-about-apis.md).
# Questions about APIs
This page provides answers to questions regarding our APIs, including their use and common practices.
Are all APIs accessed in the same way?
Yes, all of our APIs were built similarly, and require an **authentication token** to gain access to the API and its resources. You can read more about authentication in the specific API's documentation.
Why is using the GET method discouraged for some of the APIs?
When we mention using this particular method, we are referring to a specific instance of this method: one called through a **URL format**, and directly appends the parameters to the end of the URL.
This can cause formatting issues when calling the API since some of our APIs handle very complicated parameters.
How do I test an integration before going live?
Use the [API playground](https://infinitode-docs.gitbook.io/documentation/api-documentation/api-playground). It lets you build a request for any endpoint and send it in one of two ways:
* **Mock mode** (the default) returns dummy data in the real response shape — the same status codes and error messages as the live endpoint — so you can check parameter names, types and the shape of the output. It needs no API key and doesn't use any calls.
* **Live mode** sends the same request to the real endpoint with your standard API key and shows the precise response: status code, headers, timing and body. It uses one call, exactly like a request from your own code.
Mock responses are for testing, not for real data — switch to live mode when you want the endpoint's actual output for a specific request.
My API token was compromised, how can I reset it?
You can reset it yourself, without waiting on support. On your account page, your API key has a **Reset** button. A reset needs a **verified email address** and a **recent sign-in**, and you can perform up to **3 resets in a rolling seven-day window**.
* The new token takes the old one's place on the same page. Copy it into your server's environment variables and redeploy, or your app fails on its next call.
* The old token is **invalidated immediately**, with no grace period. From the moment you press **Reset**, any request with the old token returns `401` with `"Invalid API key."`
* Calls already spent with a leaked key, including bought calls, can't be restored.
* Use your [API call history](https://infinitode-docs.gitbook.io/documentation/api-documentation/keeping-your-api-key-safe#see-what-your-keys-were-used-for) to see what was done with the token before you reset it.
If a leak looks like abuse rather than an accident — or you've run out of resets for the week — contact support with the details and we'll help.
How often can I reset my API key?
Up to **3 times in a rolling seven-day window**.
To reset a token you need a **verified email address** and a **recent sign-in** on the account page. If your account page is hiding your key, verify your email first: verification is also what unlocks the reset button.
The cap is a safety measure on our side, not something to spend: you shouldn't normally have a reason to reset a key more than once in a month, and keeping resets in reserve means you can replace a leaked key yourself, immediately, when it actually matters. If you do run out, contact support and we'll sort it out.
Keep in mind that a reset is instant and permanent for the old token: there's no grace period, and no way to get the old value back.
What is in my API call history?
Your account page lists every API call made with your key for the **last 30 days**, so you can see exactly what happened and how your calls were used. You can **filter by time**, move through the history with the **chart** on the page, and **export** the results as **CSV or JSON** — up to **5,000 entries** are returned per query, so narrow the time filter for a busy account. Each entry shows:
| Field | What it tells you |
| ------------- | ----------------------------------------------------------------------------------------- |
| Date and time | When the call was made |
| API | Which endpoint the call hit, e.g. `/api/v1/bmi` |
| Method | Whether it was a `POST` or a `GET` call |
| Token used | The **final three characters** of the key used, and whether that key was still **active** |
| Status | The response status and **result category**, with the error message for calls that failed |
| Origin | An approximate **country and city**, and the **origin or referrer** the call came from |
| Call used | Whether that request counted against your calls |
* **Errors are listed too:** rejected requests (`400`, `405`, `429`, an invalid key, or no calls left) are included and marked as **not** using a call.
* **Every call is in one list,** no matter where it came from: your own code, a serverless function, or the live mode of the [API playground](https://infinitode-docs.gitbook.io/documentation/api-documentation/api-playground).
* **Entries survive a token reset** — calls made with a leaked token are still there after you replace it, which is how you identify what an old key was used for.
* **Only call metadata is stored:** the fields above — not your request parameters, not the output the API returned, **not the full API key**, and **not your raw IP address**. Location is approximate city-level detail, not a precise address.
* **30 days is a rolling window:** older calls drop off the list automatically, so export anything you need to keep.
Do my monthly allowance and my bought calls get used in a particular order?
Yes — **monthly first, then bought**. Your plan's monthly allowance is spent before any calls you bought in a pack, so bought calls last as long as possible, and they never expire.
Two things worth remembering:
* **There is one balance per account.** Your monthly allowance is spent first, then any calls you've bought — including calls used by the API playground's live mode.
* **Only metered calls consume anything.** Requests rejected before your key is accepted — invalid parameters (`400`), the wrong method (`405`), a rate limit (`429`), an invalid key, or an empty balance — cost nothing. A failure after your key is accepted and a call has been metered may use that call.
What are experimental APIs?
Experimental APIs are normal APIs, that run on our infrastructure, but they haven't met the mark in terms of goal, accuracy, or reliability, according to our team. These APIs may produce outputs that are irrelevant, misleading, or incorrect at times. They are not intended for production environments.
What happened to the Developer API token?
It's been retired, and so have developer calls. Every account now has one key — the **standard API key** (`INF-`) — with a single call balance, and every call returns the endpoint's actual output. There is no separate `DEV-` key, developer allowance, `validationResults` field or dummy output any more.
Any request that presents a `DEV`-prefixed key is rejected with `401 {"error": "Invalid API key."}`, so remove the old key from any deployment or environment file you still have it in.
Testing moved to the [API playground](https://infinitode-docs.gitbook.io/documentation/api-documentation/api-playground), which does the same job better: build a request for any endpoint, run it in **mock mode** to get dummy data in the real response shape with no key and no calls used, then switch to **live mode** when you want the endpoint's precise response.
Nothing else changes: your standard API key keeps working, and any calls you've bought stay on your account.
How can I get support if I run into issues with an API?
There's a form for each kind of request, so your message reaches the right place:
| Your question is about | Use this form |
| --------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Sign-in, key setup or reset, usage meters, call history | [Account and API-key help](https://infinitode.netlify.app/forms/account-help/) |
| A PayPal payment, subscription, cancellation or access-end date | [Billing question](https://infinitode.netlify.app/forms/billing-question/) |
| A call-pack refund | [Pack refund](https://infinitode.netlify.app/forms/billing-refund/) |
| A bug in an API endpoint, app, experiment or the website | [Bug report](https://infinitode.netlify.app/forms/bug-report/) |
| A security concern or suspicious activity | [Incident report](https://infinitode.netlify.app/forms/report-activity/) |
| Enterprise enquiries, or something else | [Contact form](https://infinitode.netlify.app/forms/contact/) |
When you submit a form while signed in, your account and recent-purchase details are verified on our side, so you don't need to explain which plan you're on or when you last paid. **Never include your password or a full API key** in a form — we'll never ask for them. We'll get back to you as soon as possible.
Do you provide SDKs for your APIs in different programming languages?
We do not provide language-specific SDKs. However, we do provide basic code examples and OpenAPI specification files to help you get started. Our APIs are platform-agnostic and can be accessed using any language or tool that supports standard REST calls, such as cURL, JavaScript, Python, and more.
Where can I find OpenAPI specification files for your APIs?
OpenAPI specification files are available for each API at `https://infinitode.netlify.app/openapi/api-name/openapi.yaml`. Replace "api-name" with the specific API you're working with. These files can be imported into tools like Postman, Insomnia, or used to generate client libraries in your preferred programming language.
How do I choose between using GET and POST methods?
Both methods are supported, but we recommend POST for most use cases, especially when dealing with complex parameters or sensitive data. GET requests append parameters to the URL, which can cause formatting issues with complicated parameters and may expose sensitive information in server logs. POST requests send parameters in the request body, providing better security and handling of complex data structures.
What's the best practice for handling API errors in my application?
Implement proper error handling by checking HTTP status codes and parsing error messages. Common practices include: implementing retry logic with exponential backoff for temporary errors (like 429 rate limits), logging errors for debugging, gracefully handling different error types, and providing meaningful error messages to end users.
Not every error costs a call. Requests that are rejected before your key is accepted cost nothing:
| Status | Meaning | Uses a call? |
| --------------------------------- | --------------------------------------------------------------------------------- | ------------ |
| `400` | Missing or invalid parameters | No |
| `405` | Wrong HTTP method | No |
| `429` | Rate limit exceeded (25 requests per minute per key) | No |
| `401` `"Invalid API key."` | The key is wrong, revoked, replaced by a reset, or missing its `INF-` prefix | No |
| `401` `"No remaining API calls."` | Your monthly allowance **and** your bought calls are used up | No |
| `401` with another message | The request was accepted but failed while processing (e.g. an invalid expression) | **Yes** |
Can I make concurrent API calls to improve performance?
Yes, you can make concurrent API calls, but be mindful of rate limits which vary by API and plan. Implement proper throttling to avoid hitting rate limits, which would result in 429 errors. Rate-limited requests don't use a call, since they're rejected before your key is accepted. Check the specific API documentation for rate limit details.
How do I integrate APIs into my business applications?
Start by reviewing the API documentation for your specific use case, then test the request in the [API playground](https://infinitode-docs.gitbook.io/documentation/api-documentation/api-playground) — mock mode first, live mode when you want real output. Once tested, implement proper error handling, security measures (like [securing your API key](https://infinitode-docs.gitbook.io/documentation/api-documentation/keeping-your-api-key-safe)), and monitoring. Consider implementing caching where appropriate to optimize performance and reduce API usage.
Are there usage analytics available for my API calls?
Yes. Your account page shows your remaining monthly calls, your plan's allowance, and any bought calls, along with a **30-day history of every call** made with your key: the endpoint it hit, the method, the status code and error message for failures, which key was used (final three characters) and whether it was active, the result category, an approximate country and city, the origin or referrer, and whether the request used a call. You can filter it by time, move through it with the chart, and **export it as CSV or JSON** — up to 5,000 entries per query. See [API call history](https://infinitode-docs.gitbook.io/documentation/api-documentation/keeping-your-api-key-safe#see-what-your-keys-were-used-for).
Your balance and your call history live on your account page only — there's no endpoint that returns them.
What happens if I exceed my API rate limits?
If you exceed rate limits, you'll receive a 429 error response. Rate-limited requests aren't charged: they're returned before any call is used. To avoid this, implement proper rate limiting in your application and consider upgrading your plan if you consistently hit limits. Rate limit specifications are detailed in each API's documentation.
Why can't I see my API keys yet?
Your account page reveals your API key only after you **verify your email address** — email sign-ups get a verification link when they register. Until your email is verified you also can't buy a plan or a pack, enrol an authenticator app, or reset a key.
If the link hasn't arrived, open the confirmation screen you saw after signing up and use **resend verification email**, or open your dashboard from that screen to check the account's current state. Remember to check spam folders, and make sure the address on the account is the one you can receive mail at. See [What email verification unlocks](https://infinitode-docs.gitbook.io/documentation/account-security-billing#what-email-verification-unlocks).
Can I call the API from the browser?
Yes. All endpoints allow cross-origin requests, so a web page can call the API directly with `fetch`. Don't put your **API key** in public front-end code, though: anyone can open the browser's developer tools and copy it, and it spends your calls. Test with mock mode in the [API playground](https://infinitode-docs.gitbook.io/documentation/api-documentation/api-playground) instead, and call the API from your own server or serverless function in production. See [Keeping your API key safe](https://infinitode-docs.gitbook.io/documentation/api-documentation/keeping-your-api-key-safe).
Can I use your APIs for creative projects and applications?
Absolutely! Our APIs are designed to support creative professionals and projects. Whether you're building interactive installations, generative art applications, content creation tools, or innovative user experiences, our APIs provide the flexibility and capabilities needed for creative work. Check our AI APIs for particularly creative applications.
How do I use the OpenAPI files for testing and integration?
The OpenAPI specification files (available at `https://infinitode.netlify.app/openapi/api-name/openapi.yaml`) can be used with a variety of tools to streamline testing and integration. You can import these files into API clients like Postman or Insomnia to automatically generate collections of API requests, making it easy to send test requests and see live responses. For more detailed instructions on how to use these files with specific tools, please refer to the documentation for each API.
{% hint style="info" %}
Make sure to properly handle errors when using our APIs. Common errors are listed in each APIs' documentation pages.
{% endhint %}
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://infinitode-docs.gitbook.io/documentation/faqs/questions-about-apis.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.