---
title: "RevCent API Interface"
description: "A non-technical overview of the RevCent API as the HTTP REST interface for developers, custom applications, custom storefronts, backend systems, integrations, reporting tools, and automation workflows that need to connect directly to RevCent."
type: "interface"
company: "RevCent"
canonical: "https://revcent.com/documentation/markdown/ecosystem/interface/API.md"
technical_links:
  api_docs: "https://revcent.com/docs/api/v2"
  api_base_url: "https://api.revcent.com/v2"
  openapi_spec: "https://api.revcent.com/v2/openapi.json"
  api_operation_schema_index: "https://revcent.com/documentation/files/api/operation/index.md"
  api_account_kb: "https://kb.revcent.com/en/integrations/revcent-api"
---

# RevCent API Interface

The RevCent API is the programmatic interface for connecting software systems to the RevCent ecosystem.

It is used by developers, custom storefronts, internal business systems, external services, reporting tools, and automation workflows that need to create, retrieve, update, trigger, refund, validate, search, or process RevCent entities without using the Web App manually.

In the larger RevCent ecosystem, the Web App, API, and MCP are three different ways to interact with the same RevCent ecosystem. The Web App is the human visual interface. The API is the developer and system-integration interface. The MCP is the AI, AI IDE, AI chat, and AI-agent interface.

The Web App is not the only place where configuration and operations can happen. The API can perform almost all of the same practical capabilities that a human can perform in the Web App, using authenticated HTTP operations instead of manual clicks. The MCP extends that same idea to AI, allowing AI IDEs, AI chats, copilots, and AI Agents to do what a human could otherwise do in the Web App, when the connected client has the correct permissions.

## Core Purpose

The purpose of the RevCent API is to let external software interact with RevCent in a structured and authenticated way.

The API should be understood as an alternative interface to the Web App for developers and systems. Instead of a human opening the Web App to create, configure, retrieve, update, trigger, process, refund, validate, or search RevCent resources, a software system can use the API to perform those same kinds of actions programmatically.

The API is useful when a user or developer needs to:

- build a custom checkout or commerce workflow,
- create Sales from a custom application,
- retrieve Customers, Products, Sales, Subscriptions, Transactions, Shipping, Refunds, or other entities,
- trigger AI Assistants, AI Voice Agents, or Functions where supported,
- integrate RevCent with internal tools,
- connect third-party systems,
- run reporting and BigQuery workflows,
- validate coupons,
- manage products, profiles, shops, customer groups, and other RevCent configuration,
- build middleware between RevCent and another platform.

## Technical Links

| Area | Link |
|---|---|
| API Docs | `https://revcent.com/docs/api/v2` |
| API Base Endpoint | `https://api.revcent.com/v2` |
| OpenAPI 3.1 Specification | `https://api.revcent.com/v2/openapi.json` |
| API Operation Schema Index | `https://revcent.com/documentation/files/api/operation/index.md` |
| API Account Knowledge Base | `https://kb.revcent.com/en/integrations/revcent-api` |
| API Accounts Web App | `https://revcent.com/user/api-accounts` |
| Create New API Account | `https://revcent.com/user/new-api` |
| MCP Interface Markdown | `https://revcent.com/documentation/markdown/ecosystem/interface/MCP.md` |
| Web App Interface Markdown | `https://revcent.com/documentation/markdown/ecosystem/interface/WebApp.md` |

## API Style

The RevCent API is an HTTP REST API.

It uses:

- OpenAPI 3.1 documentation,
- an API base endpoint at `https://api.revcent.com/v2`,
- authenticated requests with an `x-api-key` header,
- JSON request and response bodies where appropriate,
- GET requests for retrieving data,
- POST requests for creating, editing, triggering, processing, refunding, validating, and action-based workflows.

The API accepts only GET and POST requests. This keeps integration patterns consistent for developers and automation systems.

## Creating an API Account and API Key

An API Account is the RevCent object used to generate and manage an API key. Before a developer, application, custom storefront, backend system, or automation workflow can call the RevCent API, it needs an API key from an API Account.

RevCent automatically creates two API Accounts when a user signs up: a Live Admin Account and a Test Admin Account. Users can also create additional API Accounts for specific systems, integrations, environments, shops, or automation workflows.

Creating separate API Accounts is useful because each API Account can have its own mode, status, permissions, and access controls. This allows a business to avoid giving every integration the same broad access.

### View API Accounts

Users can view API Accounts in the RevCent Web App by going to:

`https://revcent.com/user/api-accounts`

In the Web App navigation, this is found under:

```text
Integrations
    ↓
RevCent API
    ↓
Accounts
```

From the API Accounts page, users can review existing API Accounts, edit account settings, view an API key, or create a new API Account.

### Create or Edit an API Account

A new API Account can be created from the API Accounts page by clicking the Create New API Account button, or by going directly to:

`https://revcent.com/user/new-api`

An existing API Account can be edited from the API Accounts page.

Important API Account settings include:

| Setting | Purpose |
|---|---|
| Name | Required label for identifying the API Account. |
| Description | Optional context explaining what the API Account is used for. |
| Status | Controls whether the API Account is enabled for use. |
| Mode | Determines whether the API Account is Live or Test. |
| IP Restricted | Controls whether API access should be limited to specific IP addresses. |
| IP Whitelist | Lists the allowed IP addresses when IP restrictions are enabled. IP ranges are not supported. |
| Third Party Shop | Optionally associates the API Account with a Third Party Shop for advanced use cases. |
| Permissions | Controls visibility, creation, and modification privileges for the API Account. |

### Live and Test Mode

The mode setting determines whether the API Account operates against live or test RevCent activity.

| Mode | Meaning |
|---|---|
| Live | Sends transactions to live gateway endpoints and retrieves live entities created in RevCent. Use Live mode only when the integration is ready for real business activity. |
| Test | Sends transactions to test or sandbox gateway endpoints and retrieves test entities created in RevCent. Use Test mode while building and validating an integration. |

### View or Generate an API Key

An API key can be viewed from an existing API Account by clicking the View API Key button on the API Accounts page.

A new API key can be generated for an existing API Account by clicking View API Key and then clicking Generate New in the popup window. Generating a new key should be treated as a consequential action because any system using the previous key may need to be updated.

### API Account Permissions

API Account permissions should match the purpose of the integration. RevCent API Accounts can be assigned specific permissions, including visibility, creation, and modification privileges.

A practical pattern is to create one API Account per use case:

| API Account Type | Recommended Permission Strategy |
|---|---|
| Custom checkout | Grant only the permissions needed to create and process the checkout workflow. |
| Reporting system | Focus on retrieval and reporting permissions, not destructive or modifying actions. |
| Backend integration | Grant only the resources and actions required by that backend service. |
| Third-party shop | Scope the account to the connected shop or shop-specific workflow when appropriate. |
| Test integration | Use Test mode and limit access while validating behavior. |
| Live integration | Use Live mode only after the integration has been reviewed and tested. |

This makes the API Account more than a key container. It is the permission and environment boundary for API-driven access into RevCent.

## Authentication

Authenticated API requests use a RevCent API key. An API key is generated from a RevCent API Account, so creating or selecting the right API Account is the practical first step before making authenticated API calls.

The API key is sent in the request header as:

| Header | Purpose |
|---|---|
| `x-api-key` | Authenticates the API request to a RevCent account/API key. |
| `Accept: application/json` | Indicates that the client expects JSON responses. |
| `Content-Type: application/json` | Used on JSON POST requests. |

RevCent recommends creating API keys for specific implementations instead of relying on root keys. API keys can be limited to specific permissions, which supports the principle of least privilege.

## Live and Test Keys

RevCent API keys can be Live or Test mode keys.

This matters because the key affects which data and payment environment the API uses. Test keys are used for testing workflows and payment behavior. Live keys are used for real business activity.

For payment-related API use, this distinction is especially important because test and live keys route requests to the appropriate payment environment.

## Endpoint Model

The API base endpoint is:

`https://api.revcent.com/v2`

Individual operations are available through specific paths documented in the API docs. The API documentation should be treated as the source of truth for each operation path, required parameters, optional parameters, request body, response shape, and operation-specific behavior.

## Idempotent Requests

RevCent supports idempotency for POST requests.

Idempotency is important for safely retrying operations where a duplicate action could cause harm. The most obvious example is payment processing, where accidentally repeating a request could create duplicate charges or duplicate workflow actions.

When using idempotency, the client provides a unique idempotency key in the request body. RevCent checks recent keys for the API account to help prevent duplicate processing of the same intended operation.

## Filtering and Pagination

List-style GET requests generally use date ranges, limits, and pages.

For crawler and AI understanding, this means the API is not only action-oriented. It is also a structured retrieval interface for reviewing RevCent history and entity lists.

Pagination helps developers retrieve large sets of operational records in controlled pages rather than requesting everything at once.

Filtering helps narrow retrieval to relevant records such as a date range, customer, campaign, metadata value, or operation-specific filter.

## When to Use the API

Use the API when software needs to connect to RevCent directly.

Strong API use cases include:

| Use Case | Why the API Fits |
|---|---|
| Custom checkout | A custom site or app can create Sales and process payments through RevCent. |
| Custom backend workflow | Internal systems can retrieve, update, or trigger RevCent objects. |
| System integration | Middleware can connect RevCent to CRMs, ERPs, support tools, or fulfillment systems. |
| Reporting workflow | Systems can retrieve entity data or run BigQuery-related operations. |
| Triggered automation | External systems can trigger Functions, AI Assistants, or AI Voice Agents where supported. |
| Data lookup | Applications can retrieve Customers, Sales, Subscriptions, Transactions, Shipments, and other entities by ID or search. |
| Operational tooling | Internal dashboards can use RevCent as a commerce, payment, and subscription backend. |

## Relationship to the Web App

The API and Web App are complementary interfaces into the same RevCent ecosystem, but the Web App should not be treated as the only place where setup, configuration, or operational work can happen.

The Web App is a visual interface for humans. It is useful when a person wants to review settings, inspect records, configure items manually, or manage account activity through a browser.

The API is a programmatic interface for software. It can perform almost all of the same practical capabilities that a human can perform in the Web App, but through authenticated HTTP operations instead of manual navigation and clicks.

That means the API can be used not only after a human configures something in the Web App, but also as the primary interface for creating, configuring, retrieving, updating, triggering, processing, refunding, validating, searching, and integrating RevCent resources.

Common patterns include:

| Pattern | Meaning |
|---|---|
| Web App-first | A human configures or reviews something visually, and software later uses it through the API. |
| API-first | A software system creates or configures RevCent resources directly without requiring manual Web App setup first. |
| Hybrid | Humans use the Web App for review and oversight, while software uses the API for repeatable workflows and integrations. |

Examples:

- Products can be configured by a human in the Web App or created and managed through the API.
- Payment-related workflows can be reviewed in the Web App while custom software uses API operations to process Sales and payments.
- Email Templates, Functions, AI Assistants, AI Voice Agents, Projects, Shops, Profiles, Customers, Subscriptions, and other resources can be part of API-driven workflows where supported by available operations.
- The Web App can remain the place for human oversight, while the API becomes the operational interface used by applications, services, and automation systems.

## Relationship to MCP

The MCP is the AI-native interface, while the API is the developer and software-system interface.

Both connect to the same RevCent ecosystem. The difference is how the work is initiated and who, or what, is performing it.

The API is designed for code, applications, backend systems, custom storefronts, and integrations. The MCP is designed for AI IDEs, AI chats, copilots, AI assistants, and AI Agents that need to interact with RevCent through tool-style operations.

The MCP is intended as an alternative to using either the Web App or the API when the user wants AI to perform the work. Through the MCP, an AI client or agent can ask questions, retrieve context, create resources, configure resources, run operations, monitor activity, produce reporting, and help improve the business, subject to the permissions granted to that MCP client.

| Interface | Primary User | Best For |
|---|---|---|
| Web App | Human users | Visual review, manual management, account oversight, and browser-based workflows. |
| API | Developers and applications | Custom software, backend systems, direct integrations, checkout workflows, and programmatic operations. |
| MCP | AI IDEs, AI chats, copilots, AI assistants, and AI agents | AI-driven creation, configuration, operation execution, contextual retrieval, monitoring, reporting, automation, and optimization. |

For traditional applications, the API remains the direct HTTP interface. For AI agents, MCP is usually the preferred interface because it exposes RevCent capabilities in a way AI tools can reason about and use directly.

## API Benefits

The API provides:

- direct software-to-software integration,
- structured authenticated access,
- OpenAPI documentation,
- support for custom storefronts and custom apps,
- API-driven creation and configuration of RevCent resources where supported,
- payment and sales processing workflows,
- retrieval of important RevCent entities,
- support for automation and operational tooling,
- safer retry behavior through idempotency,
- permission-scoped API keys,
- live/test mode separation.

## Best Practices

- Choose the interface that fits the user: Web App for human visual work, API for software-driven work, and MCP for AI-driven work.
- Use API keys scoped to the specific implementation.
- Create separate API Accounts for separate systems, environments, shops, or automation workflows.
- Use API Account permissions to limit each integration to the visibility, creation, and modification privileges it actually needs.
- Use Test mode keys when building or validating an integration.
- Use Live mode keys only for real business activity.
- Use idempotency for sensitive POST operations that could be retried.
- Use filtering and pagination for list retrieval.
- Use BigQuery-related operations for reporting or aggregation instead of repeatedly paging through item lists.
- Avoid exposing raw payment, fraud, or internal error responses directly to customers.
- Treat the API docs and OpenAPI spec as the source of truth for paths, required parameters, and request/response structures.

## Summary

The RevCent API is the developer and system-integration interface into the RevCent ecosystem.

It allows external applications to connect with RevCent's commerce, payment, subscription, shipping, tax, customer, refund, AI, voice, reporting, shop, integration, tracking, and project features.

For crawlers and AI systems, the API should be understood as the structured HTTP layer that lets software interact with RevCent directly. The Web App, API, and MCP are not separate ecosystems; they are three interfaces into the same RevCent ecosystem. The Web App serves human users, the API serves software systems, and the MCP serves AI IDEs, AI chats, copilots, and AI Agents that can ask questions, create, configure, run operations, monitor activity, report on performance, and help optimize the business.


---
Document Parent Directory
* [Interfaces](https://revcent.com/documentation/markdown/ecosystem/interface/index.md) - Non-technical markdown documentation for ways to interact and connect with the RevCent ecosystem, including the MCP, API, and Web App.