powered by
Ways to use it

Backend as a Service

Updated Mar 19, 2026
Anythink is a full Backend as a Service — everything your application needs on the server side, managed from one dashboard, without writing backend code.

What is a Backend as a Service?

When you build an application, you need two things: a frontend (what users see) and a backend (the database, APIs, and logic that power it). Building a backend from scratch takes weeks, requires DevOps knowledge, and needs constant maintenance.

A Backend as a Service (BaaS) gives you that entire layer pre-built. You define your data model, and everything else — the database, REST API, authentication, file storage, user management — is provided and managed for you.

Anythink is designed for teams who want to ship quickly without compromising on production quality.


What Anythink provides out of the box

Automatic REST APIs

Design your data model in the dashboard and Anythink instantly generates a full REST API for every entity. No code, no configuration — you get:

  • GET /org/{orgId}/entities/{entity}/items — list records (filtering, sorting, pagination)
  • GET /org/{orgId}/entities/{entity}/items/{id} — get a single record
  • POST /org/{orgId}/entities/{entity}/items — create a record
  • PUT /org/{orgId}/entities/{entity}/items/{id} — update a record
  • DELETE /org/{orgId}/entities/{entity}/items/{id} — delete a record

Every endpoint is live the moment the entity is saved. Interactive API documentation is generated automatically and linked from your dashboard.


Data model and entities

Define the data your application needs by creating entities — the tables in your database — through the visual dashboard. Choose from a full range of field types: text, numbers, dates, booleans, files, geographic points, JSON, and foreign keys to link entities together.

All data is stored in a managed PostgreSQL database. You never touch the infrastructure directly.


User management and authentication

Anythink includes a full user management system. Users sign up and log in via email and password or Google OAuth. Each user receives a JWT on authentication that they use to make authenticated API calls.

Access is controlled through roles — groups of permissions that determine what each user can read, create, update, or delete. Row-Level Security lets you lock records so users can only access their own data.


File storage

Upload images, documents, videos, or any file type through the dashboard or API. Files are stored securely and delivered via CDN. Each file can be marked public (accessible without authentication) or private (requires a valid token).

Files attach to entity records using a file field — upload a product image and link it to the product record in one step.


Workflow automation

Workflows are the automation layer inside Anythink. Chain together steps — read data, write data, call external APIs, run JavaScript, branch on conditions — and trigger them on a schedule, when a record changes, or via a custom HTTP endpoint.

Common uses: send a welcome email when a user signs up, generate content from an LLM when a record is created, sync data to an external CRM on a schedule, expose a custom API endpoint for your frontend to call.


Payment processing

Accept payments through Stripe without building your own payment infrastructure. Connect your Stripe account via the dashboard, then use the payments API to create charges, manage payment methods, and review transaction history.


Dashboard for your team

Every part of your backend is manageable through the Anythink dashboard — not just for developers. Non-technical teammates can browse and edit data, approve content, manage users, and review workflow runs. No database client, no SQL, no terminal required.


How your frontend connects

Your frontend makes standard HTTP requests to your Anythink API URL. Use fetch, axios, or any HTTP client:

javascript
// Fetch a list of products
const response = await fetch(
  'https://api.my.anythink.cloud/org/{orgId}/entities/products/items',
  {
    headers: { 'Authorization': 'Bearer ' + userToken }
  }
);
const data = await response.json();

Your API URL base:

http
https://api.my.anythink.cloud/org/{orgId}/

The open-source CLI

Everything you can do in the dashboard is also available from the terminal using the Anythink CLI. Create entities, manage data, trigger workflows, upload files, manage secrets, and more.

Install via Homebrew:

bash
brew tap anythink/tap
brew install anythink

The CLI is open source. Use it to automate deployments, script data migrations, and integrate Anythink into CI/CD pipelines.


Compared to building your own backend

Capability Anythink Build it yourself
REST API Instant, auto-generated Weeks of development
Database Managed PostgreSQL Configure and maintain
Authentication Built-in (email + Google OAuth) Build from scratch
File storage Included with CDN S3 + CloudFront setup
User management Dashboard + API Build admin interface
Scaling Automatic Your responsibility
Maintenance Managed Your responsibility

Headless CMS

Updated Mar 19, 2026
Anythink works as a headless CMS — store your content as entities, manage it in the dashboard, and serve it via API to any frontend, app, or channel.

What is a headless CMS?

A traditional CMS (like WordPress) couples the content management interface with the delivery layer — it both stores content and renders web pages.

A headless CMS separates the two. Content is stored and managed in one place, and delivered via API to whatever front-end needs it — a website, a mobile app, a smart TV, a voice assistant, anything. Your frontend fetches content as JSON and renders it however it wants.

Anythink makes this trivial. Create entities to model your content, manage it in the dashboard, and serve it via auto-generated REST API.


Modelling content with entities

Any content type can be represented as an entity. Examples:

Blog / editorial site:

text
articles
  title           varchar    required
  slug            varchar    unique
  body            text       rich-text
  published_at    timestamp
  status          varchar    (draft / published)
  author          → users
  hero_image      file
  tags            varchar[]  multi-select

Product catalogue:

text
products
  name            varchar    required
  description     text
  price           float
  sku             varchar    unique
  category        → categories
  images          file       (multiple)
  in_stock        boolean    default true

Navigation / menus:

Manage nav structures in the dashboard and serve them via API — no hardcoded links in your frontend. See Menu Configuration.


Managing content in the dashboard

The Anythink dashboard is your editorial interface. Non-technical team members can:

  • Create and edit records for any entity
  • Upload images and files
  • Filter and search content
  • Use rich-text editing for long-form content
  • Manage relationships between content types (e.g. attach an author to an article)

Roles and permissions control who can see and edit what — a content editor role can be given access only to specific entities.


Fetching content via API

Your content is available via the standard entity API:

javascript
// Fetch published articles
const res = await fetch(
  'https://api.my.anythink.cloud/org/{orgId}/entities/articles/items?filter[status]=published',
  { headers: { 'Authorization': 'Bearer ' + token } }
);
const { items } = await res.json();

For fully public content that requires no authentication, use the public search endpoint:

javascript
// Public content — no auth required
const res = await fetch(
  'https://api.my.anythink.cloud/org/{orgId}/search/public?e=articles&q=*'
);
const { items } = await res.json();

Multi-channel delivery

The same API powers every channel. One Anythink project can serve content to:

  • A Next.js or Nuxt website (server-side rendering or static generation)
  • A React Native mobile app
  • A Webflow site via custom code
  • An email newsletter tool
  • Any other system that can make an HTTP request

Real-time content updates

Because Anythink's API always returns the current state of your database, content changes made in the dashboard appear in your frontend immediately — no rebuild, no re-deploy.

For static site generators (like Next.js with ISR), use webhooks or workflow triggers to signal a revalidation when content is updated.


Using Anythink as your marketing site CMS

The Anythink marketing site itself is powered by Anythink — articles, product pages, and all structured content are stored as entities and served via API to a Next.js frontend. The same approach works for any content-driven site.

Payment Engine

Updated Mar 19, 2026
Accept payments and manage transactions through Anythink's built-in Stripe integration. Connect your Stripe account once and use the payments API to create charges, manage payment methods, and review transaction history.

How it works

Anythink's payment engine is built on Stripe Connect. You connect your Stripe account to your Anythink project — this is a one-time setup — and from that point, all payments flow through Stripe with Anythink managing the API layer.

This means:

  • Stripe handles card processing, PCI compliance, and fraud detection
  • Anythink gives you a clean API and dashboard layer to work with
  • You can accept cards, Apple Pay, Google Pay, and all payment methods Stripe supports

Setting up Stripe Connect

From the dashboard

  1. Go to Settings → Payments in your Anythink dashboard
  2. Click Connect with Stripe
  3. You will be redirected to Stripe to complete the onboarding process
  4. Once approved, your Stripe account status appears as Active in the dashboard

From the CLI

bash
anythink pay status
anythink pay connect

Via the API

Create a Stripe Connect account:

http
POST /org/{orgId}/integrations/anythinkpay/stripe-connect

Get your onboarding link (to redirect users to Stripe's onboarding flow):

http
POST /org/{orgId}/integrations/anythinkpay/stripe-connect/onboarding

Check your account status:

http
GET /org/{orgId}/integrations/anythinkpay/stripe-connect

Taking payments

1. Payment intents (recommended)

The standard Stripe flow for taking a payment.

Create a payment intent:

http
POST /org/{orgId}/integrations/anythinkpay/payments

Request body:

json
{
  "amount": 2999,
  "currency": "gbp",
  "description": "Order #1042",
  "metadata": {
    "orderId": "1042"
  }
}

Amount is in the smallest currency unit (pence for GBP, cents for USD).

Confirm a payment intent (after collecting card details client-side with Stripe.js):

http
POST /org/{orgId}/integrations/anythinkpay/payments/payment-intent/{paymentIntentId}/confirm

Capture an authorised payment (for two-step auth + capture flows):

http
POST /org/{orgId}/integrations/anythinkpay/payments/payment-intent/{paymentIntentId}/capture

Check payment intent status:

http
GET /org/{orgId}/integrations/anythinkpay/payments/payment-intent/{paymentIntentId}

2. Charging a saved payment method

If a customer has saved their card (using the setup intent flow below), you can charge them directly.

http
POST /org/{orgId}/integrations/anythinkpay/payments/charge-payment-method

Request body:

json
{
  "paymentMethodId": "pm_...",
  "amount": 1499,
  "currency": "gbp"
}

Managing payment methods

Allow customers to save their payment details for faster checkout.

Create a setup intent

Use this client-side to collect and vault a card without charging it.

http
POST /org/{orgId}/integrations/anythinkpay/payment-methods/setup-intent

After the customer completes the Stripe.js form with this setup intent, their payment method is saved and can be charged later.

List saved payment methods

http
GET /org/{orgId}/integrations/anythinkpay/payment-methods

Remove a payment method

http
DELETE /org/{orgId}/integrations/anythinkpay/payment-methods/{paymentMethodId}

Viewing payment history

From the dashboard

Go to Payments in your Anythink dashboard for a full transaction list with filtering by status.

From the CLI

bash
anythink pay payments
anythink pay payments --limit 50

Via the API

All payments:

http
GET /org/{orgId}/integrations/anythinkpay/payments

Filter by status (succeeded, pending, failed):

http
GET /org/{orgId}/integrations/anythinkpay/payments/status/succeeded

Get a specific payment:

http
GET /org/{orgId}/integrations/anythinkpay/payments/{paymentId}

Platform fees (marketplace use)

If you are building a marketplace where you take a percentage of transactions between buyers and sellers, Anythink supports platform fee configuration.

View your fee configuration:

http
GET /org/{orgId}/integrations/anythinkpay/stripe-connect/fees

Calculate the fee for a given amount:

http
POST /org/{orgId}/integrations/anythinkpay/stripe-connect/fees/calculate

Stripe test mode

During development, use Stripe test cards to simulate payments without real charges. Stripe test card numbers are available in the Stripe documentation.

Your Stripe Connect dashboard will show whether you are in test or live mode. Anythink passes through your Stripe mode automatically.

How integrations work

Updated Sep 30, 2026
Integrations let your workflows call Slack, Google Calendar, GitHub, OpenAI and more, using OAuth or API-key connections Anythink stores encrypted for you.

An integration lets your project call an external service — post a Slack message, create a Google Calendar event, read a GitHub repository, generate text with Claude — without writing the HTTP calls or storing tokens yourself. Anythink defines each provider; you connect your project to it and call it from a workflow's Integration step.

This page explains the model. To connect your first integration, see Post to Slack when a record is created.

Definitions and connections

Part What it is
Definition A provider: Slack, GitHub, Google Calendar. Anythink maintains these — each has an auth type, the OAuth scopes it requests and its operations.
Connection Your project's link to a definition: a name plus encrypted credentials. A project can hold several connections to the same provider.
Operation One thing a provider can do, such as Slack's send-message or Google Calendar's create-event, with a fixed set of inputs.

See what's available under Settings › Integrations in the Anythink dashboard, or with anythink integrations list and anythink integrations connections list. Integration providers and operations reference lists every provider and operation.

Project connections and user connections

A connection belongs either to the whole project or to one user:

  • Project connection (the default): shared by every workflow. Use it for a team Slack workspace or a shared booking calendar.
  • User connection: one user links their own account, and only jobs that user triggers can pick it up. Use it when a workflow should act as the person who triggered it.

The dashboard creates project connections. Create user connections with the CLI's --user-connection flag or is_user_connection: true on the API — see Let each user connect their own account.

Choosing a connection in a workflow step

Each Integration step has a Credential Source that decides which connection it uses:

Credential Source (dashboard) Value Uses
System (shared connection) system An enabled project connection for the provider.
Current User (first connection) current_user An enabled connection visible to the user who triggered the job: their own user connection or a project connection.
Specific Connection (by ID) connection The connection with the given ID, which can be a template such as {{ $anythink.trigger.data.connection_id }}. If no connection has that ID, the step falls back to current_user.
Entity Field entity_field Credentials from a template that resolves to a stored credentials object, such as a secret field on the triggering record.

When more than one connection matches system or current_user, Anythink doesn't guarantee which one it picks. Keep one enabled connection per provider for those sources, or use Specific Connection (by ID).

OAuth and API-key providers

Each definition has one auth type:

  • OAuth2: Slack, Google Calendar, GitHub, LinkedIn and Twitter / X. You register an OAuth app with the provider, save its client ID and secret in your project, then approve access in the browser. Anythink exchanges the authorisation code for an access token and, where the provider issues one, a refresh token.
  • API key: Claude AI, OpenAI and Grok. You paste the key once and Anythink stores it encrypted.

The OAuth app belongs to your project, so the consent screen shows your app's name, and you control its scopes and redirect URLs. See Connect Slack to send messages from workflows and Connect Google Calendar to create events from workflows for the setup per provider.

Note: Google, GitHub, LinkedIn and Apple can also be used for social sign-in — letting your users log in with that provider. That's configured on the Social Sign-In tab and uses a different callback URL from integration connections. Most providers allow one callback URL per OAuth app, so use a separate OAuth app for each purpose. Google allows several redirect URIs on one OAuth client.

How credentials are handled

Connection credentials — access tokens, refresh tokens and API keys — are encrypted at rest and decrypted only on Anythink's servers when a step needs them. The dashboard, the CLI and the API return a connection's ID, name, provider, owner, enabled flag and timestamps, never its credentials.

When an OAuth access token has expired and the connection has a refresh token, the Integration step refreshes it before calling the provider and saves the new token.

Parent providers

Google Calendar has Google as its parent provider. If Google Calendar has no OAuth credentials of its own, it uses the Google credentials saved for your project — so a project that already has Google sign-in set up can connect Google Calendar without registering another app. Google Calendar is currently the only Google service available as an integration.

Turning things off

  • Disable a connection to stop workflows picking it up without deleting its credentials: anythink integrations disable <connection-id>. Re-enable it with anythink integrations enable <connection-id>.
  • Disconnect to delete the connection and its credentials: Disconnect in the dashboard or anythink integrations disconnect <connection-id>.

See Rotate, pause or disconnect an integration for the full procedure.

Where connections are used

  • The Integration workflow step calls one operation with a connection chosen by its credential source. See Step types for its parameters and output.
  • The AI sidebar's bring-your-own-key mode uses the project's claude, openai or grok connection instead of Anythink's shared AI quota.

Limits

Limit Detail
User connections One per user, per provider, per project. Connecting the same provider again as the same user fails; disconnect the old one first.
Connections per provider in the dashboard The dashboard shows and manages one connection per provider. Add more project connections with the CLI or API.
Connection choice system and current_user pick any matching enabled connection, in no guaranteed order.
GitHub results List operations return one page of up to 100 results. There's no page input; narrow the range with since and until where the operation has them.
Connection test anythink integrations test confirms the connection exists. It doesn't call the provider — run the workflow to check the credentials work.
Callback URLs Most OAuth providers allow one callback URL per app, so social sign-in and integration connections for the same provider need separate apps.

Next steps

How AI chat and MCP work

Updated Sep 30, 2026
How Anythink's AI chat panel and MCP server let Claude read and change your project's data, which providers they use, and where each one stops.

Anythink gives AI models access to your project in two ways: an AI chat panel in the Anythink dashboard that answers questions and makes changes through tools, and an MCP server (anythink-mcp) that lets Claude Code, Claude Desktop or another Model Context Protocol client work on your project from outside the dashboard.

Both use the same set of tools, and both act with your permissions. For calling a model as a step inside an automation, see the Integration step in Step types.

The moving parts

Part What it is
AI chat panel The panel you open from the bot icon in the dashboard's header. It streams a reply and can call tools mid-conversation to read or change data.
Provider The model vendor behind a chat: Claude (Anthropic), OpenAI or Grok (xAI).
AI mode Anythink AI (platform-managed, uses your credit balance) or Bring Your Own Key (your provider key, billed by the provider).
Connection A provider API key stored for your project, encrypted at rest. Added in Settings › AI Settings or Settings › Integrations.
MCP server anythink-mcp, a .NET tool you install and run locally. Your MCP client launches it and talks to it over stdio.
MCP tool One capability the server exposes: signing in, choosing a project, or running an Anythink CLI command. See MCP server tools reference.

How a chat message runs

  1. You send a message in the AI panel, optionally with image or PDF attachments.
  2. Anythink picks the provider from the model name. Models starting gpt-, o1, o3 or o4 go to OpenAI, grok- models go to Grok, gemini- models go to Gemini, and everything else (including all Claude models) goes to Claude.
  3. It picks the credentials. In Bring Your Own Key mode, Anythink uses your enabled connection for that provider. In Anythink AI mode, or if you have no connection for that provider, it uses the platform key and checks your credit balance first.
  4. It runs the conversation loop. The model replies; if it asks for a tool, Anythink runs the tool as you and feeds the result back. This repeats until the model stops asking for tools, up to 10 rounds.
  5. The reply streams back as it's generated, with a marker each time a tool runs.
  6. The conversation is saved so you can reopen it from Chat history in the panel.

Before the first round, Anythink gives the model a short summary of your project: how many entities it has and the names of the 10 most recently created ones. Anything more, it has to fetch with a tool.

Note: Only Claude models call tools. OpenAI and Grok models chat without tools, so they can't look at your data.

Anythink AI vs Bring Your Own Key

Choose the mode in Settings › AI Settings › AI Provider.

Mode Behaviour
Anythink AI Uses Anythink's credentials and your credit balance. Pick the model under Default Model. When the balance runs out, the chat stops with a message telling you to top up or switch to your own key.
Bring Your Own Key Uses the key you save under API Keys for the provider of the model you pick in the panel. Billed by the provider, with no credit usage.

In Bring Your Own Key mode, the panel only lists models that work with your own keys. If you pick a model whose provider has no saved key, Anythink falls back to the platform key and your credit balance, which only works for Claude models. To use OpenAI or Grok in chat, save a key for that provider first.

Note: AI Settings lists Gemini and a saved Gemini key does work in the panel, but the API Keys section's Connected badge only checks for Claude, OpenAI and Grok connections — a saved Gemini connection never shows as connected there, even though chat requests to gemini- models use it.

The same Claude, OpenAI and Grok connections power the Integration workflow step. See How integrations work and Integration providers reference.

The MCP server

anythink-mcp is published from the public anythink-cli repository as a .NET global tool. Your MCP client starts it as a local process. It reads the same saved profiles as the anythink CLI, and its cli tool runs your installed anythink binary. That means the assistant can run any CLI command you could. To set it up, see Connect Claude to your backend with MCP.

The dashboard AI panel reaches the same tools through a copy of the server that Anythink hosts. It supports a subset of CLI commands (listed in MCP server tools reference), and it isn't an MCP endpoint you can connect your own client to.

The server has 16 tools: five for signing in and out, three for local profiles, three for billing accounts, four for projects, and a cli tool that runs Anythink CLI commands.

Permissions

The AI panel and the MCP server act as you (or as the API key you connected with). There's no separate AI or MCP permission: a tool call succeeds only if your role allows the same action through the CLI or API.

To Permission
Use the AI chat panel anythink_ai_chat:create
See available models and your chat history anythink_ai_chat:read
Read or change the project's AI mode and default model anythink_ai_config:read / anythink_ai_config:update
Save or replace a provider key in AI Settings anythink_integrations:read, :create and :delete
Run a one-off prompt with anythink integrations execute anythink_integrations:read

Tool calls need the permission for what they touch. Listing entities needs anythink_entities:read; creating a workflow needs anythink_workflows:create.

Limits and trade-offs

Limit Detail
Tool rounds per message 10. If the model is still calling tools after that, the reply ends where it is.
Providers that use tools Claude only. OpenAI and Grok chat without tools.
Gemini Works in chat, but a saved Gemini key never shows as Connected on the AI Settings page — that badge only checks Claude, OpenAI and Grok connections.
Attachments JPEG, PNG, GIF, WebP or PDF, up to 5 MB each and 5 per message.
anythink integrations execute Claude only. OpenAI and Grok aren't supported by this command yet; use the Integration workflow step for them.
Commands in the dashboard panel A subset of CLI commands. Integrations, menus, payments, migrations and search only work through a local MCP server.
Characters in cli commands Commands can't contain query strings (?, &), currency symbols or most punctuation beyond - . / : = , @ " ' { } [ ].
Chat history Saved per user, per project. You see only your own conversations.

Next steps

Related Articles

Discover more content related to ways to use it.