Coming from Flask-Admin

starlette-admin began as a port of Flask-Admin's concepts to the ASGI ecosystem, so the migration is direct. You still subclass a ModelView, configure it with class attributes, and register it on an Admin instance. Most of the work is renaming attributes and moving 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's no template_mode switch. The UI uses Tabler (Bootstrap 5) and includes dark mode. To change the look, write a custom BaseTheme or override the templates.

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"]

CSV and JSON export is on by default. Row caps apply automatically, and spreadsheet formula escaping is an opt-in exporter setting. Import, which Flask-Admin doesn't provide, includes a preview step with per-row validation and optional updates to 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. It resolves rows lazily, exposes the active filters, and works the same way when a user selects all matching records across pages. Actions can also render a custom HTML form inside the confirmation dialog. For per-row operations, @row_action and @link_row_action replace custom column formatters.

Permissions and access control

Flask-Admin's can_* class flags become per-request methods in starlette-admin, so authorization decisions can depend on the signed-in user.

With Flask-Admin, you integrate Flask-Login yourself. starlette-admin ships an AuthProvider with a ready-made sign-in page, and you implement the login, logout, and authenticate methods against your user store. An OAuthProvider covers OIDC redirect flows. The signed-in user is available everywhere as request.state.admin_user.

Model lifecycle hooks

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

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]

An explicit class gives each inline model the full ModelView configuration surface: 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 configuration object instead:

from starlette_admin import I18nConfig

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

Timezone-aware datetime rendering works the same way, through TimezoneConfig. See Internationalization and Timezones.

What you gain by switching

• An async stack. Runs natively on FastAPI and Starlette, with support for async SQLAlchemy, Beanie, and Tortoise ORM. Flask-Admin is synchronous.
• Security features built in. CSRF protection, upload filename sanitization, image content verification, and export row limits are on as soon as you instantiate Admin, and you can enable spreadsheet formula escaping on the exporters. See Security.
• Data import. A preview step validates every row before anything is written. Flask-Admin has no import feature.
• A dashboard widget system. Build index pages and custom views in Python instead of hand-writing templates.
• Modern design. An actively maintained codebase with a polished UI, built-in dark mode, and first-class type hints.

What you must adapt to

• Explicit request objects. There's no ambient request context. Every hook and permission method receives the request as a parameter.
• Async handlers. Hooks and actions are coroutines, so keep blocking calls out of them or move that work to a thread.
• No FileAdmin. If your workflow depends on browsing the server file system, starlette-admin doesn't cover it.
• No create or edit modals. Forms render as full pages rather than popup modals.