DMVCFramework: Delphi REST API, JSON-RPC & Web App Framework

The #1 most popular open-source Delphi framework on GitHub · Production-ready since 2010

TL;DR: DMVCFramework is the #1 Delphi framework for building REST APIs and web services. It’s free (Apache 2.0), production-ready since 2010, supports JWT, WebSocket, ORM, and works on Windows/Linux. Install from GitHub, create a controller with [MVCPath] attributes, and return objects that auto-serialize to JSON.

What is DMVCFramework?

DMVCFramework (DelphiMVCFramework) is the most popular open-source framework for building web APIs and web applications in Delphi. It enables you to create RESTful services (RMM Level 3), JSON-RPC services, Minimal API services without controller classes, server-rendered web apps, MCP servers for AI assistants, mobile backends, and microservices.

Used in production since 2010, DMVCFramework powers some of the highest-traffic Delphi web APIs in the world. It’s the #1 Delphi project on GitHub by star rating, with a vibrant community of 6,000+ active developers.

Get Started: The Official Guide

The fastest way to learn DMVCFramework is the official guide, written by the person who maintains the framework. The second edition is written on dmvcframework-3.5.0-silicon: 30 chapters, more than 550 pages and 46 sample projects that compile, building one API from the project the wizard generates up to a server behind TLS.

It is out on Leanpub at 90%, minimum price 45 USD, and updates are free forever.

Available Editions

Edition	Language	Format	Link
2nd, 3.5.0-silicon	English	eBook	Buy on Leanpub
1st, 3.2.1-carbon	English	eBook	Buy on Leanpub
1st, 3.2.1-carbon	English	Hardcover	Buy on Lulu
1st, 3.2.1-carbon	Portuguese (BR)	eBook	Buy on Leanpub
1st, 3.2.1-carbon	Spanish	eBook	Buy on Leanpub

The second edition is English only for now, so the first edition stays the one to buy in Portuguese or Spanish, and the only one in print until the new one reaches Lulu.

Read a free sample of the second edition, or see the full table of contents.

Why Choose DMVCFramework?

What Developers Say

“DMVCFramework is a great framework. It’s very intuitive, fast, easy to use, actually there is nothing more to ask for.”

Samir

“I’m still amazed by the DelphiMVCFramework code and documentation. Thank you very much and I am amazed by your quick feedback.”

Benjamin Y., Director of SQLGate

“We started the process of migrating our systems to micro services and are loving the DMVCFramework.”

E. Costa

What’s New in DMVCFramework 3.4.3-aluminium

The latest release brings major new features:

WebSocket Support

Full-duplex real-time communication with TMVCWebSocketServer and TMVCWebSocketClient. Build chat applications, live dashboards, and collaborative tools with channel-based messaging and groups.

Rate Limiting Middleware

Protect your APIs from abuse with built-in rate limiting - both in-memory for single servers and Redis-backed for distributed environments.

Repository Pattern

Clean architecture with IMVCRepository<T> and [MVCInject] for automatic dependency injection.

Expression Support in dotEnv

Dynamic expressions in .env configuration files with variable substitution and arithmetic.

See full What’s New for 3.4.3-aluminium →

Version History

Key Features

Web API Development

• RESTful APIs - Full RMM Level 3 compliance with proper HTTP verbs and status codes
• JSON-RPC 2.0 - Automatic object remoting for RPC-style APIs
• OpenAPI Support - Automatic API documentation generation
• Automatic Routing - Attribute-based URL mapping with parameter binding

Minimal API, Web Apps and MCP Servers

• Minimal API - Routes as anonymous methods (MapGet, MapPost, MapPut, MapDelete), arguments bound by type and route groups with filters, with no controller class. New in 3.5.0-silicon: read the introduction
• Web Applications - Server-rendered HTML with TemplatePro, HTMX and WebStencils, from controllers or from Minimal API groups (.AsWeb)
• MCP Servers - Expose tools, resources and prompts of your Delphi application to Claude, Gemini or ChatGPT with the Delphi MCP toolkit, which also includes a client and an LLM agent

Authentication & Security

• JWT Authentication - Industry-standard JSON Web Tokens
• HTTP Basic Authentication - Simple username/password auth
• Custom Authentication - Flexible framework for any auth scheme
• CORS Support - Cross-origin resource sharing configuration

Real-Time Communication

• WebSocket Support - Full-duplex communication channels
• Server-Sent Events (SSE) - Push notifications to clients
• Messaging Extensions - Built-in pub/sub patterns

Data & Persistence

• MVCActiveRecord - Powerful ORM for database operations
• JSON Serialization - Automatic object-to-JSON mapping
• Custom Serializers - Full control over data transformation

Deployment Flexibility

• Windows Console Application
• Windows Service
• Linux Console/Daemon
• Apache Module (mod_proxy)
• IIS (ISAPI DLL)
• Load-balanced environments

Developer Experience

• IDE Wizard - Project templates for quick start
• 100+ Samples - Learn every feature with working examples
• Middleware System - Easy request/response hooks
• Controller Inheritance - DRY principle for common logic
• Integrated REST Client - Test and consume APIs easily

Quick Start: Hello World

Get started with DMVCFramework in minutes. Here’s a simple “Hello World” controller:

uses
  MVCFramework, MVCFramework.Commons;

type
  [MVCPath('/api')]  // Base path for all actions in this controller
  TMyController = class(TMVCController)
  public
    [MVCPath('/hello')]           // Route: GET /api/hello
    [MVCHTTPMethods([httpGET])]   // Allowed HTTP method
    function GetHello: String;

    [MVCPath('/hello/($Name)')]   // Route: GET /api/hello/{Name}
    [MVCHTTPMethods([httpGET])]   // ($Name) captures the URL segment
    function GetHelloName(const Name: String): String;
  end;

implementation

function TMyController.GetHello: String;
begin
  Result := 'Hello, World!';  // The string is sent as the response body
end;

function TMyController.GetHelloName(const Name: String): String;
begin
  Result := 'Hello, ' + Name + '!';  // Name is automatically extracted from URL
end;

That’s it! Call GET /api/hello and you get the text Hello, World!. Call GET /api/hello/John and you get Hello, John!.

DMVCFramework automatically serializes objects, arrays, records and datasets to JSON. A string is sent as it is: for a JSON body, return an object or OKResponse(...).

Advanced Example: REST API with Database

For real-world applications, DMVCFramework supports MVCActiveRecord ORM and the Repository pattern with dependency injection:

uses
  MVCFramework, MVCFramework.Commons, MVCFramework.ActiveRecord,
  MVCFramework.Repository, MVCFramework.Nullables, System.SysUtils,
  System.Generics.Collections;

type
  // Entity class mapped to database table
  [MVCTable('customers')]
  TCustomer = class(TMVCActiveRecord)
  private
    [MVCTableField('id', [foPrimaryKey, foAutoGenerated])]  // Auto-increment PK
    FID: NullableInt32;
    [MVCTableField('name')]    // Maps to 'name' column
    FName: string;
    [MVCTableField('email')]   // Maps to 'email' column
    FEmail: string;
  public
    property ID: NullableInt32 read FID write FID;
    property Name: string read FName write FName;
    property Email: string read FEmail write FEmail;
  end;

  [MVCPath('/api/customers')]
  TCustomerController = class(TMVCController)
  protected
    fRepository: IMVCRepository<TCustomer>;  // Repository interface
  public
    [MVCInject]  // Dependency injection - repository is automatically provided
    constructor Create(Repository: IMVCRepository<TCustomer>); reintroduce;

    [MVCPath]                     // Route: GET /api/customers
    [MVCHTTPMethods([httpGET])]
    function GetAllCustomers: IMVCResponse;

    [MVCPath('/($ID)')]           // Route: GET /api/customers/{ID}
    [MVCHTTPMethods([httpGET])]
    function GetCustomerByID(const ID: Integer): IMVCResponse;

    [MVCPath]                     // Route: POST /api/customers
    [MVCHTTPMethods([httpPOST])]  // [MVCFromBody] deserializes JSON body to TCustomer
    function CreateCustomer([MVCFromBody] const Customer: TCustomer): IMVCResponse;

    [MVCPath('/($ID)')]           // Route: DELETE /api/customers/{ID}
    [MVCHTTPMethods([httpDELETE])]
    function DeleteCustomerByID(const ID: Integer): IMVCResponse;
  end;

implementation

constructor TCustomerController.Create(Repository: IMVCRepository<TCustomer>);
begin
  inherited Create;
  fRepository := Repository;  // Store injected repository
end;

function TCustomerController.GetAllCustomers: IMVCResponse;
begin
  Result := OKResponse(fRepository.GetAll);  // Returns HTTP 200, body {"data": [...]}
end;

function TCustomerController.GetCustomerByID(const ID: Integer): IMVCResponse;
begin
  Result := OKResponse(fRepository.GetByPK(ID));  // Returns HTTP 200, body {"data": {...}}
end;

function TCustomerController.CreateCustomer(const Customer: TCustomer): IMVCResponse;
begin
  fRepository.Store(Customer);  // Insert or update based on PK
  Result := CreatedResponse('/api/customers/' + Customer.ID.Value.ToString);  // HTTP 201
end;

function TCustomerController.DeleteCustomerByID(const ID: Integer): IMVCResponse;
var
  lCustomer: TCustomer;
begin
  lCustomer := ToFree<TCustomer>(fRepository.GetByPK(ID));  // Load by primary key, freed at the end of the method
  fRepository.Delete(lCustomer);          // Delete from database
  Result := OKResponse;                   // Returns HTTP 200
end;

To run it, register the repository in the service container and configure the database connection: DefaultMVCServiceContainer.RegisterType(TMVCRepository<TCustomer>, IMVCRepository<TCustomer>, TRegistrationType.SingletonPerRequest); DefaultMVCServiceContainer.Build; The simple_api_using_repository_with_injection sample shows the complete setup.

Key benefits:

• Functional actions: Return IMVCResponse using helpers like OKResponse(), CreatedResponse()
• Dependency injection: [MVCInject] on constructor for automatic repository injection
• MVCActiveRecord: ORM with table mapping via attributes
• Repository pattern: IMVCRepository<T> for clean, testable data access
• Auto-serialization: Objects, records, lists, datasets are automatically serialized

Learn by Example: 100+ Sample Projects

The best way to learn DMVCFramework is by exploring working code. The project includes over 100 sample projects covering every feature and use case. Each sample is self-contained and ready to compile.

Find the sample that matches what you need to build, open it in Delphi, and start experimenting!

📦 All samples: github.com/danieleteti/delphimvcframework/tree/master/samples

“I want to create my first DMVCFramework project”

“I want to build a REST API”

“I want to add authentication and security”

“I want real-time communication”

“I want to build a Minimal API”

“I want to render HTML pages”

“I want to work with databases”

“I want to use JSON-RPC”

“I want to customize request/response handling”

“I want to deploy to production”

“I want to document my API”

“I want advanced features”

Related Open Source Projects

DMVCFramework integrates seamlessly with other open source projects by the same author:

Delphi Version Compatibility

Support the Project

Professional Services

Need enterprise-grade support? bit Time Professionals, the company behind DMVCFramework, offers:

• Training Courses - On-site or remote training for your team
• Consulting - Architecture review, performance optimization, best practices
• Custom Development - Feature development, integration, migration

📧 Contact: dmvcframework@bittime.it | 🌐 bittimeprofessionals.it

Community & Resources

FAQ: Frequently Asked Questions

What is DMVCFramework?

DMVCFramework (DelphiMVCFramework) is an open-source framework for building web APIs, RESTful services, Minimal API services, web applications and MCP servers in Delphi. It’s the most popular Delphi web framework, used in production since 2010, and is the #1 Delphi project on GitHub by star count.

What is the best framework for REST API in Delphi?

DMVCFramework is the most popular and feature-complete framework for building REST APIs in Delphi. It supports RESTful APIs (RMM Level 3), JSON-RPC, WebSocket, Server-Sent Events, JWT authentication, and includes a powerful ORM called MVCActiveRecord.

How do I create a REST API in Delphi?

Use DMVCFramework: create a controller class inheriting from TMVCController, add [MVCPath] and [MVCHTTPMethods] attributes to define routes, and return data directly from your methods (functional actions). The framework automatically serializes objects, arrays, and records to JSON. See the 100+ included samples for examples.

How do I return JSON from a Delphi REST API?

With DMVCFramework, simply return an object, record, or TObjectList<T> from your controller method. The framework automatically serializes it to JSON. For more control, use OKResponse(data) or CreatedResponse(location) helpers.

Does DMVCFramework support JWT authentication?

Yes, DMVCFramework has built-in JWT (JSON Web Token) support for stateless authentication. It supports token generation, validation, role-based authorization, and secure HTTP-only cookies. See the jsonwebtoken and jsonwebtoken_roleauth samples.

Can I use DMVCFramework on Linux?

Yes, DMVCFramework fully supports Linux deployment starting from Delphi 10.2 Tokyo. You can deploy as a console application or daemon, with full support for all features including WebSocket and SSL/TLS.

Is DMVCFramework free?

Yes, DMVCFramework is free and open-source under the Apache 2.0 license. You can use it in commercial projects without royalties. If you redistribute it, the license asks you to keep the copyright notices and a copy of the license.

How do I get support for DMVCFramework?

Multiple support options are available: join the Facebook group (6,000+ members), explore the 100+ samples included in the project, read the official guide book, or become a Patron for priority support and exclusive content.

Does DMVCFramework support WebSocket?

Yes, DMVCFramework includes full WebSocket support for real-time bidirectional communication. Features include channel-based messaging, groups, and JavaScript client examples. It also supports Server-Sent Events (SSE) for server-to-client push notifications.

What is MVCActiveRecord?

MVCActiveRecord is DMVCFramework’s built-in ORM (Object-Relational Mapper) that simplifies database operations. It uses attributes for table/column mapping, supports CRUD operations, relationships, and RQL (Resource Query Language) for flexible querying.

How do I deploy DMVCFramework to production?

DMVCFramework supports multiple deployment options: Windows console application, Windows Service, Linux daemon, Apache module (mod_proxy), IIS (ISAPI DLL), and load-balanced environments. See the deployment samples for each scenario.

Does DMVCFramework support OpenAPI/Swagger?

Yes, DMVCFramework can automatically generate OpenAPI (Swagger) documentation for your APIs. Use the swagger_primer and swagger_ui samples to add interactive API documentation to your project.

How do I handle file uploads in DMVCFramework?

Use the Context.Request object to access uploaded files. The file_upload sample demonstrates handling multipart/form-data requests with single or multiple file uploads.

Can I use DMVCFramework with FireDAC?

Yes, DMVCFramework works with any database access layer including FireDAC, ADO, and others. MVCActiveRecord uses FireDAC by default, but you can use any connection you prefer.

How do I implement CORS in DMVCFramework?

Use the built-in CORS middleware. Add TMVCCORSMiddleware to your server configuration to enable cross-origin requests. See the middleware_cors sample for configuration options.

What Delphi versions does DMVCFramework support?

DMVCFramework supports Delphi 10 Seattle through Delphi 13 Florence, including full Linux support from Delphi 10.2 Tokyo onwards.

How do I handle errors and exceptions in DMVCFramework?

DMVCFramework automatically converts exceptions to appropriate HTTP error responses with JSON bodies. For custom error handling, use raise EMVCException.Create() with specific HTTP status codes, or implement custom exception handlers.

Does DMVCFramework support dependency injection?

Yes, DMVCFramework has built-in dependency injection. Use the [MVCInject] attribute on constructors or method parameters to automatically inject services and repositories. See the services_injection sample.

Does DMVCFramework support Minimal API?

Yes, from 3.5.0-silicon. You define routes with MapGet, MapPost, MapPut and MapDelete and an anonymous method, with no controller class. The framework resolves arguments by type (services from the container, JSON body, query string, route parameters), and you set filters per route group. See the minimal_api sample and the introduction to Minimal API.

Can I build web applications, not only APIs?

Yes. DMVCFramework renders HTML on the server with TemplatePro (Mustache and WebStencils are also supported) and works with HTMX for partial page updates. Pages can come from controllers or from Minimal API groups. See the serversideviews_templatepro, htmx_website_with_templatepro and minimal_api_webapp samples.

Can I build an MCP server with DMVCFramework?

Yes. The Delphi MCP toolkit lets a DMVCFramework application expose tools, resources and prompts to AI assistants such as Claude, Gemini or ChatGPT through the Model Context Protocol, over HTTP or stdio. The same toolkit includes a client and an LLM agent.