Coming from Flask-Admin

Because starlette-admin began as a port of Flask-Admin's concepts to the ASGI ecosystem, the migration process is highly direct. You still subclass a ModelView, configure it using class attributes, and register it on an Admin instance. Most of the transition involves renaming attributes and shifting from Flask's implicit request context to Starlette's explicit request object.

This guide maps the Flask-Admin API, attribute by attribute, to its starlette-admin equivalent.

Mental Model

Setup

from flask import Flask
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView

app = Flask(__name__)
admin = Admin(app, name="My Admin", template_mode="bootstrap4")
admin.add_view(ModelView(Post, db.session))

from starlette.applications import Starlette
from starlette_admin.contrib.sqla import Admin, ModelView

app = Starlette()  # or FastAPI()
admin = Admin(engine, title="My Admin", secret_key="change-me")
admin.add_view(ModelView(Post))
admin.mount_to(app)

There is no template_mode switch. The UI uses Tabler (Bootstrap 5) with built-in dark mode support. You customize the appearance using a custom BaseTheme and template overrides.

List Page Attributes

Form Attributes

Export and Import

class PostView(ModelView):
    can_export = True
    export_types = ["csv", "xlsx"]
    export_max_rows = 10000

class PostView(ModelView):
    exporters = ["csv", "xlsx", "pdf"]
    importers = ["csv", "xlsx"]
    exclude_fields_from_export = ["internal_notes"]

Exporting to CSV and JSON is enabled by default. Row caps apply automatically, and spreadsheet formula escaping is available as an opt-in exporter setting. Importing, a feature Flask-Admin lacks entirely, includes a preview step with per-row validation and optional updates of existing records by primary key. See Export and Import.

Actions

from flask_admin.actions import action


class PostView(ModelView):
    @action("publish", "Publish", "Publish selected posts?")
    def action_publish(self, ids):
        query = Post.query.filter(Post.id.in_(ids))
        for post in query.all():
            post.published = True

from starlette_admin import ActionSelection, action, flash


class PostView(ModelView):
    actions = ["publish", "delete"]

    @action(
        name="publish",
        text="Publish",
        confirmation="Publish selected posts?",
    )
    async def publish(self, request: Request, selection: ActionSelection) -> None:
        for post in await selection.rows():
            post.published = True
        flash(request, "Posts published")

The handler receives an ActionSelection object instead of raw IDs. This object resolves rows lazily, exposes active filters, and works transparently with "select all matching" across multiple pages. Actions can also render a custom HTML form within the confirmation dialog. Additionally, @row_action and @link_row_action provide per-row operations without requiring custom column formatters.

Permissions and Access Control

Flask-Admin's can_* class flags translate to per-request methods in starlette-admin, allowing authorization decisions to depend dynamically on the logged-in user.

Flask-Admin requires you to integrate Flask-Login manually. In contrast, starlette-admin provides an AuthProvider with a ready-made login page, requiring you only to implement the login, logout, and authenticate methods against your user datastore. It also offers an OAuthProvider for OIDC redirect flows. The authenticated user is accessible globally via request.state.admin_user.

Model Lifecycle Hooks

Beyond per-view hooks, the event system allows a single handler to observe every view. Flask-Admin has no equivalent feature.

from starlette_admin.events import AdminEvent, AfterCreateContext


async def audit(ctx: AfterCreateContext) -> None: ...


admin.events.on(AdminEvent.AFTER_CREATE, audit)

Custom Views and the Index Page

Inline Models

class ArticleView(ModelView):
    inline_models = [Comment]

from starlette_admin.contrib.sqla import InlineModelView, ModelView


class CommentInline(InlineModelView):
    model = Comment
    fields = ["author", "body"]


class ArticleView(ModelView):
    inlines = [CommentInline]

Using an explicit class gives you the full ModelView configuration surface for each inline model. This includes field selection, validation, and composite foreign key support. See Inline Forms.

Internationalization

Flask-Admin depends on Flask-Babel and the surrounding Flask environment. starlette-admin uses a dedicated configuration object:

from starlette_admin import I18nConfig

admin = Admin(engine, i18n_config=I18nConfig(default_locale="fr"))

You configure timezone-aware datetime rendering similarly using TimezoneConfig. See Internationalization and Timezones.

What You Gain by Switching

• An async stack. Runs natively on FastAPI and Starlette, bringing full support for async SQLAlchemy, Beanie, and Tortoise ORM. Flask-Admin remains strictly synchronous.
• Security features built in. CSRF protection, upload filename sanitization, image content verification, and export row limits are enabled automatically when you instantiate the Admin class, and spreadsheet formula escaping can be enabled on the exporters. See Security.
• Robust data import. Includes a built-in preview step that validates every row before writing, a feature Flask-Admin lacks entirely.
• A dashboard widget system. Construct index pages and custom views programmatically instead of relying on hand-written templates.
• Modern design. An actively maintained codebase utilizing a polished UI, built-in dark mode, and first-class type hinting.

What You Must Adapt To

• Explicit request objects. There is no ambient request context. Every hook and permission method receives the request object explicitly as a parameter.
• Async handlers. Hooks and actions are coroutines. You must avoid blocking calls inside them or offload them to separate threads.
• No FileAdmin. If your workflow relies heavily on browsing the server file system directly, be aware that this specific feature does not exist in starlette-admin.
• No create/edit modals. Forms are built as complete, standalone pages rather than popup modals.