MoonShine

An admin for
your API.

Connect your service and ask your agent to build an admin. It creates tables, forms and relations through MCP. Works with REST APIs on any stack.

Install MoonShine V How it works

StorePython / Django

CRMGo

ContentNode.js

ServicePHP / Laravel

Any stack. Connected through REST APIs.

Beyond the stack

Your stack. Your choice.
All it takes is a REST API.

Python / DjangoNode.js / ExpressGoJava / SpringPHP / Laravel+ your stack

01 / FROM INTENT TO INTERFACE

From your API
to working screens.

Your agent inspects your API, creates resources and configures fields. You review the result in your browser.

Your agent MCP

You

“Build an admin for my store. I need products, orders and customers.”

Interactive example

MoonShine

Store / build preview

01 / CONNECTION

Your service is connected.

Your agent verified API access. It can now inspect your store’s data.

Shop APIPython / Django

MoonShine /shop-admin

API address: shop.example/api
Authentication: API token
Access check: 200 OK

API connected. A dedicated store panel is registered.

Example workflow · sample data

02 / MULTIPLE SERVICES

Each service gets
its own panel.

A Python store. A Go CRM. Content on Node.js. Your agent connects each service to MoonShine V and creates its own panel.

Separate routes, configuration and authentication for each service.

MoonShine

/shop-admin

Products

Create

products128

new orders12

ProductStatusPrice

Orbit headphonesIn stock$129

Lunar keyboardIn stock$89

Station displayLow stock$249

Panel preview · sample data

03 / CAPABILITIES

Tables, forms
and access to data.

MoonShine tools for your API, from record lists to authentication and relations.

Tables and forms.

Tables, forms, search and filters. Your agent creates resources around the real entities in your API.

Relations between records.

Orders and customers. Articles and authors. Relations within a service and across connected services.

Authentication and access.

Tokens, OAuth 2.0 and sessions. Authentication configured per API, with SSO support for panels.

Updates through MCP.

A new field, filter or section? Ask your agent to update the panel through MCP. No manual admin code edits.

04 / YOUR ADMIN, ONE MESSAGE AWAY

An admin you can
talk to.

Check on orders. Create content. Get a summary across your services. Just send a message — your agent carries out the task through MCP and replies in the same chat.

Messenger Agent MCP MoonShine

Connect a bot in your messenger to an agent with access to MoonShine V’s MCP. It can work with your connected services using the available tools and permissions.

MoonShine Your agent in your messenger

MCP

YOU

How many orders today? Show me the ones awaiting payment.

MoonShine

12 orders today. Four are still awaiting payment:

#1048Awaiting payment

#1049Awaiting payment

#1052Awaiting payment

#1055Awaiting payment

Source: store → orders

Example conversation · sample data

05 / FROM SETUP TO YOUR ADMIN

Install MoonShine .
Connect your agent.

MoonShine V runs separately. Your agent works in your project. MCP connects the two.

Start with Docker.

Open your MoonShine V source directory. You need Docker running and Compose 2.30+. PHP and dependencies are built inside the container.

MoonShine V directory

Build and application key

cp docker/.env.example docker/.env
docker compose --env-file docker/.env \
  -f docker/docker-compose.yml build api-admin-fpm
docker compose --env-file docker/.env \
  -f docker/docker-compose.yml run --rm --no-deps \
  api-admin-fpm php -r \
  'echo "base64:".base64_encode(random_bytes(32)).PHP_EOL;'

Copy the generated base64:… key into APP_KEY in docker/.env. Then start the stack:

Start

docker compose --env-file docker/.env \
  -f docker/docker-compose.yml up -d --build

Local admin: localhost:8080. Your service’s API must be reachable from Docker.

02
Connect MCP.
Choose your agent and add the configuration to your service project. It connects your agent to the running MoonShine V container.
Your service project
.mcp.json
```
{
  "mcpServers": {
    "moonshine-v": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "exec", "-i", "moonshine-api-admin-fpm",
        "php", "artisan", "api-admin:mcp-server"
      ]
    }
  }
}
```
In your service’s project root. Approve the project connection when Claude Code starts. Use /mcp to check the server.
Documentation Claude Code
.cursor/mcp.json
```
{
  "mcpServers": {
    "moonshine-v": {
      "command": "docker",
      "args": [
        "exec", "-i", "moonshine-api-admin-fpm",
        "php", "artisan", "api-admin:mcp-server"
      ]
    }
  }
}
```
In your service’s project directory. Open the project in Cursor and enable the server in MCP settings. Use Agent mode.
Documentation Cursor
.codex/config.toml
```
[mcp_servers.moonshine-v]
command = "docker"
args = [
  "exec", "-i", "moonshine-api-admin-fpm",
  "php", "artisan", "api-admin:mcp-server"
]
```
In your service’s directory, in a trusted project. To use it across projects, add the section to ~/.codex/config.toml. Check it in the CLI with /mcp.
Documentation Codex
If a config already exists, add only the moonshine-v entry. Keep your other MCP connections.
03
Give it the first task.
In your service project, run claude for Claude Code, codex for Codex, or open Agent chat in Cursor. Paste the prompt. Your agent asks about the API and builds the panel.
Your agent conversation

First promptMCP / ADMIN
Connect my service to MoonShine V through MCP. First ask for the REST API URL and documentation, authentication requirements and entities. Inspect API responses, configure a dedicated panel, resources, fields, relations, filters and supported actions. Verify the result. If there are multiple services, create a separate panel for each. Do not invent endpoints or enable operations the API does not support.

AFTER YOUR FIRST LAUNCH

Built. Now make it yours.

Keep shaping your admin through MCP: colors, branding and layout. Ask your agent to update the palette, use your logo, collapse the sidebar or reorder the menu.

Colors Branding Layout

YOUR NEXT MESSAGE TO THE AGENT

Update my panel through MCP: primary color #91CAFF, my logo, a collapsed sidebar and Orders first in the menu. Ask for the logo URL and service name if they are missing from context. Apply the changes with configure_layout.

06 / QUESTIONS

Before you install.

Does my service need Laravel?

No. MoonShine V works with REST APIs over HTTP. Your service can use Python, Go, Java, Node.js, PHP or another stack. Laravel and MoonShine run inside the admin itself.

What does the agent do?

Through MCP, your agent registers the service, inspects endpoints and response formats, creates resources and configures fields, relations, navigation and styling. It can update the panel through the same tools later.

Can I connect multiple services?

Yes. Each service has its own panel, routes, configuration and authentication. Connected services can use different stacks and API response formats.

Will any API work?

You need an accessible REST API with a clear data structure. Your agent configures response mapping, pagination and supported operations. Creating, editing, deleting, searching and sorting depend on your API capabilities.

Connect
your API.

Install MoonShine V

An admin for
your API.

From your API
to working screens.

Your service is connected.

API responses become entities.

Products

Products

Each service gets
its own panel.

Products

Deals

Articles

Tables, forms
and access to data.

Tables and forms.

Relations between records.

Authentication and access.

Updates through MCP.

An admin you can
talk to.

Install MoonShine .
Connect your agent.

Start with Docker.

Connect MCP.

Give it the first task.

Built. Now make it yours.

Before you install.

Connect
your API.

An admin foryour API.

From your APIto working screens.

Your service is connected.

API responses become entities.

Products

Products

Each service getsits own panel.

Products

Deals

Articles

Tables, formsand access to data.

Tables and forms.

Relations between records.

Authentication and access.

Updates through MCP.

An admin you cantalk to.

Install MoonShine .Connect your agent.

Start with Docker.

Connect MCP.

Give it the first task.

Built. Now make it yours.

Before you install.

Connectyour API.

An admin for
your API.

From your API
to working screens.

Each service gets
its own panel.

Tables, forms
and access to data.

An admin you can
talk to.

Install MoonShine .
Connect your agent.

Connect
your API.