Manage Databases with Adminer: One File, No Mercy
I still remember the time a client’s WordPress site went belly-up at 11 p.m. on a Friday. The hosting control panel’s copy of phpMyAdmin refused to load—timed out three times in a row. I was stuck on a creaky shared server with no SSH, no WP-CLI, and a database that needed a single row flipped from wp_options. Then I remembered Adminer. I uploaded one 500-kilobyte PHP file to a subdirectory, opened it in the browser, logged in, ran a five-second UPDATE, and closed the tab. The site came back before midnight. That’s the promise of Adminer: a database management tool that’s so stripped down it feels almost rude to call it an application. But for people who actually have to get things done, its minimalism hits different.
This article is for everyone from the junior developer who’s just met SELECT * to the grumpy DBA who’s seen too many bloated “enterprise” dashboards. I’ll walk you through what Adminer is, where it came from, why you might pick it over the usual suspects, where it falls short, and how to squeeze every drop of value out of a single-file Swiss Army knife. I’ll give you download links, security recipes, plugin ideas, Docker tricks, and a pile of honest opinions. By the end, you’ll either be a convert or you’ll know exactly why you still prefer something heavier—no hard feelings either way.
I will guide you to get a free hosting account to install Adminer... At the end of the article.
What Exactly Is Adminer?
Adminer (formerly phpMinAdmin) is a database management tool that comes as a single PHP file—one adminer.php of roughly 400–500 KB, depending on the version. You drop it on a web server that runs PHP, and you instantly get a browser-based interface for managing databases. It supports MySQL, MariaDB, PostgreSQL, SQLite, MS SQL, Oracle, Elasticsearch (via plugin), MongoDB (via plugin), SimpleDB, Firebird, and more. It’s written by Jakub Vrána, who started the project in 2007 as a lightweight replacement for phpMyAdmin. The project’s tagline used to be “One file is all it takes,” and that’s still the core idea.
Under the hood, Adminer is a clever piece of engineering. It detects what database extensions your PHP installation has loaded and adapts. The code is procedural PHP, which means it runs fast and doesn’t require a framework or Composer dependencies. It uses sessions for login persistence, supports multiple authentication methods, and can store server connection presets in the file itself or in a separate adminer.css / plugins.php setup. You can even compile your own version with custom plugins baked in.
The official website is adminer.org. From there, you can grab the latest stable release, the development version, or the “Editor” variant, which is a slimmed-down edition focused on data editing for end users rather than full DBA features. The source code lives on GitHub at github.com/vrana/adminer. As of mid-2026, the project remains actively maintained, with several releases per year that mainly address new PHP compatibility, security fixes, and small enhancements.
A Quick History for Context
Adminer’s story matters because it explains the philosophy. Jakub Vrána created it after growing tired of phpMyAdmin’s size, complexity, and installation overhead. In the mid-2000s, phpMyAdmin was a sprawling collection of hundreds of files, often pre-installed by hosting providers in a way that left outdated versions lying around. Vrána thought, “Why should a database manager need more than one file?” So he built one. The first public release was in July 2007. He originally named it phpMinAdmin, but the similarity to “phpMyAdmin” caused confusion and, allegedly, some grumbles from that project’s community. He renamed it Adminer in 2009.
The tool gained quiet traction among developers who valued portability. Over time, plugin support was added, the CSS was revamped (and you can customize it with your own adminer.css), and the list of supported database systems grew. The design stayed stubbornly utilitarian. No fancy JavaScript grids. No drag-and-drop query builders. Just straightforward forms, drop-downs, and a text area for SQL. That hasn’t changed much, and I’m grateful for it.
Who This Tool Is For (and Not For)
I’m going to break this down by professional level because Adminer lands differently depending on where you sit.
Complete beginners can use Adminer to peek into a database for the first time. You’ll need the database credentials and a way to upload the file. Once it’s running, you see a login screen, pick the database driver, and you’re in. The interface lists tables on the left, and clicking a table shows its structure, data, and an SQL command box. No onboarding wizard, no glossy tutorials—just the raw tools. That can be intimidating. I’d recommend beginners watch one short video or read the built-in help (there’s a small “?” icon) and then just start exploring a test database. It’s a fast way to learn SQL because the command box encourages you to type.
Front-end developers and freelancers often bounce between client hosting accounts with wildly different setups. Adminer is perfect here. You’re not installing anything; you’re dropping a file. Hosting doesn’t have phpMyAdmin? No problem. Need to quickly check a staging database on a server where you don’t have SSH? Upload, login, done. Delete the file afterward. The risk surface is tiny.
Back-end developers may use Adminer as a secondary tool alongside an IDE’s database pane or a CLI like psql or mysql. For writing complex queries, the IDE wins. For quick lookups or running a set of migrations on a server where only HTTP is available, Adminer is brilliant. You can also write custom plugins that add buttons to run your own scripts—more on that later.
System administrators and DBAs tend to have strong opinions. Some I’ve spoken to (real names withheld by request) dismiss Adminer as a toy. Others carry it on a USB stick for emergencies. If you’re managing hundreds of database instances with orchestration tools, you probably won’t use Adminer as your primary interface. But for one-off dives into a customer’s neglected database, or for colleagues who are afraid of the terminal, Adminer lowers the barrier without locking you into a heavy platform. I’ve also seen sysadmins bundle Adminer into Docker images as a lightweight management sidecar.
If you need multi-user access control, a visual query builder, scheduled backups, or pretty dashboards, Adminer won’t make you happy. That’s fine. It knows what it is.
The Pros: Where Adminer Shines
Let me lay out the advantages without the usual marketing fluff.
1. A single file you can take anywhere. No unzipping archives, no Composer dependencies, no database migrations to run for the tool itself. Download, rename to something unguessable (like db_panel_x9.php), upload, and visit the URL. If your host runs PHP 7.4 or later, it works. I’ve used it on shared cPanel hosting, a $5 VPS, a Raspberry Pi, and even a local PHP built-in server during development. The file’s small footprint means it loads fast even on slow connections.
2. Broad database support out of the box. The main file handles MySQL, MariaDB, PostgreSQL, SQLite, MS SQL, Oracle, Firebird, SimpleDB, and Elasticsearch (some with a plugin). That’s more than many GUI tools. I’ve connected to a SQLite file locally just by pointing the login form to the file path, no extra setup. The driver detection is automatic; you just select the system type.
3. Speedy and lightweight. Because the codebase is lean, Adminer renders pages quickly. No heavy JavaScript frameworks load the browser down. That matters when you’re on a metered mobile hotspot debugging a client’s site. I also appreciate that it doesn’t trigger a thousand requests for assets.
4. Extendable through plugins. You create a plugins.php file listing the plugins you want, and Adminer loads them. Official plugins include things like adding a dump with data only, a login password reset link, a file upload for SQL execution, toggling foreign key checks, and a nice table-structure overview. You can write your own with minimal PHP knowledge. I’ve built a tiny plugin that adds a “Copy table as new table” button because I needed it for a migration script.
5. Security can be solid if you put in the work. Adminer itself doesn’t store your passwords; it passes them to the database. You can add HTTP Basic Auth via .htaccess/.htpasswd or nginx config. You can also restrict access by IP, bind the login to predefined servers in the source code, or even remove the server selection dropdown altogether. The tool is as secure as the layer you wrap around it. The fact that it’s one file makes it easy to remove after use, which is a security feature in itself.
6. Great for emergency recovery. I’ve lost count of the times Adminer saved me when a site’s admin panel broke and I needed to correct a value in the users table or disable a misbehaving plugin. Because it requires no installation, I can get in and out in under a minute.
7. No lock-in. Adminer doesn’t create its own metadata tables or store anything persistent unless you ask it to. You’re just using a temporary client.
8. Active maintenance. Jakub Vrána still releases updates. In the last year, there have been fixes for PHP 8.3, updated translations, and driver improvements. The community around it is small but real. You won’t find a glossy corporate roadmap, but that’s part of the charm.
9. Available in many languages. Adminer includes translations for over 40 languages, and the interface picks up the browser’s language settings automatically or via a config option. That’s helpful for teams spread across regions.
10. Editor variant for non-technical users. If you need to give a client a simple way to edit specific table rows without exposing the full database structure, Adminer Editor strips away everything except data browsing and basic CRUD. It’s still a single file. I’ve set this up for a small business owner who wanted to update a price list in a database without learning SQL. With some CSS customization, it looked like part of their own system.
The Cons: Where Adminer Will Annoy You
I’m not here to sell you a dream. Here’s what’s frustrating.
1. The interface looks dated. There’s no gentle way to say it. The default design is functional grey with blue links and tiny icons. If you care about aesthetics, you’ll either customize the CSS or wince every time you open it. There are community themes, but none ship officially. The responsive design works, but it feels like a 2010 mobile site.
2. No visual query builder. You write SQL in a text box. That’s it. For people who rely on phpMyAdmin’s “Query by Example” or the visual joins in tools like DBeaver, this is a non-starter. I’m comfortable typing SQL, so I rarely miss it. But I’ve watched non-developers freeze when faced with a blank textarea.
3. Limited user management. You can’t create or edit database users through Adminer in a friendly way. You can run the raw SQL (CREATE USER, GRANT), but there’s no GUI for that. For MySQL/MariaDB, phpMyAdmin’s user management tabs are genuinely useful. Adminer’s creator decided that’s outside scope, and I get it—but it’s a gap.
4. No saved queries or server-side bookmarks. You can bookmark the URL of a query result, but Adminer doesn’t remember your frequent queries. You’ll need a separate text file or a snippet manager. I keep a Markdown file with common maintenance queries for each project.
5. Plugin discoverability is weak. The official plugin list exists on the site, but it’s not curated like a package registry. You’ll find a handful of useful ones and then a bunch of obscure, rarely updated plugins. Quality varies. You might need to read PHP code to see if a plugin still works with the latest version.
6. No built-in multi-tab browsing. You can open multiple browser tabs, but Adminer doesn’t help you switch between them from within the tool. phpMyAdmin’s navigation tree and tab system are more polished for jumping between tables.
7. Occasional driver quirks. I’ve hit a situation with PostgreSQL where Adminer’s SQL export used backticks instead of double quotes, which required a manual find-and-replace. With MS SQL, some data types didn’t display perfectly. These edge cases usually get fixed, but they’re annoying when you’re in a hurry.
8. It’s not an ORM, a migration tool, or a monitoring solution. That seems obvious, but I’ve seen people complain that Adminer doesn’t have schema diffing or automatic backups. It’s a client. Pair it with other tools, like mysqldump wrapped in cron, or use a proper migration system like Flyway or Liquibase.
9. No official Docker image maintained by the project. You can find community images, and I’ll show you a simple Dockerfile later. But you have to trust third parties or build your own. The official download remains a raw PHP file.
10. Documentation is sparse. The website has a few pages of help, some FAQs, and plugin docs. There’s no big manual. You learn by doing, or by reading the source code. I’m comfortable with that, but it’s a barrier for newcomers.
Adminer vs. phpMyAdmin: A Fair Comparison
I’ll compare them on things that actually affect your day, not feature matrices.
Installation and deployment: Adminer is one file; phpMyAdmin is a directory tree of thousands of files, plus Composer dependencies in modern versions. If you just want to get in and out, Adminer wins by a mile.
Feature set: phpMyAdmin has a graphical query builder, visual database designer, user management, export templates, replication status, advisor system, and more. Adminer intentionally leaves those out. If you need those features, phpMyAdmin earns its disk space.
Performance: Adminer’s pages load faster, especially on budget hosting. phpMyAdmin’s JavaScript-heavy interface can lag on slow connections.
Security track record: Both have had vulnerabilities. phpMyAdmin’s larger attack surface and widespread default installation have made it a bigger target historically. Adminer’s simplicity works in its favor—no external libraries to exploit. Both require hardening (IP restrictions, HTTPS, removal after use).
Look and feel: phpMyAdmin’s newer themes (like Metro) look modern. Adminer’s default theme looks like it time-traveled from 2008. You can fix it with CSS, but it’s a DIY effort.
Community and support: phpMyAdmin has massive forums, Stack Overflow coverage, and books. Adminer’s community is small. If you’re stuck, you’ll likely read the source. But that source is small enough to understand.
My honest take: if you’re running a hosting company and need a user-friendly interface for customers, go with phpMyAdmin. For your own quick tasks, or when you need a portable tool, Adminer is often faster and less annoying. I keep both in my toolbox and reach for Adminer first unless I specifically need phpMyAdmin’s user manager.
How to Get Adminer and Start Using It
Go to adminer.org and click the download link for the latest version. As of now, the current stable is 4.8.1 (I’m writing in mid-2026). You’ll get a file named adminer-4.8.1.php. Rename it to something not easily guessed—avoid adminer.php or db.php. I use a random string like a47b9c.php. Store it in a web-accessible directory on your server.
To use it with MySQL:
- Open
https://yoursite.com/secret-dir/a47b9c.php. - Fill in the server (usually
localhost), username, and password. Choose the database or leave it blank to see all. - Click “Login.” You’re in.
For SQLite:
- In the server field, enter the path to your SQLite file (e.g.,
/var/www/data/app.db). Adminer will connect directly. No username/password needed unless you’ve set one.
For PostgreSQL, select “PostgreSQL” from the dropdown, provide host, user, password, and database name. Works the same.
If your PHP installation lacks the required extension (e.g., pdo_mysql, mysqli, pdo_pgsql), Adminer will tell you. Fix that first.
Pro tip: You can add a plugins.php file in the same directory to enable plugins. For example, to add the “dump to JSON” plugin, create a plugins.php with:
<?php
return [
new AdminerDumpJson
];You’ll also need the plugin class file. The official site lists available plugins with download links.
Hardening Adminer for Production or Client Use
The biggest risk is leaving Adminer accessible on the internet without any authentication beyond the database login. That’s asking for brute-force attempts, or for a random person to find it and try default credentials. Here’s my recipe.
1. Rename the file to something unguessable. This is security through obscurity, but it stops automated scanners that look for /adminer.php.
2. Add HTTP Basic Auth. On Apache, use a .htaccess file in the directory where the Adminer file sits:
AuthType Basic
AuthName "Restricted Area"
AuthUserFile /path/to/.htpasswd
Require valid-userCreate the password file with htpasswd -c /path/to/.htpasswd username. For nginx, add auth_basic directives to the location block.
3. Restrict access by IP. In Apache:
Require ip 192.168.1.0/24In nginx, use allow and deny. Combine with Basic Auth for belt-and-suspenders.
4. Pre-configure the server connection. Edit the adminer.php file (make a backup) and fill in the $adminer->server and $adminer->username variables. This hides the login form and connects immediately. You can even define multiple servers in the $adminer->servers array. Combined with IP restriction, you eliminate the login screen entirely for trusted environments.
5. Use HTTPS only. Never access Adminer over plain HTTP. If you’re on a local network and can’t get a certificate, at least use a self-signed one for testing, but never expose admin panels without TLS.
6. Delete the file when you’re done. I can’t stress this enough. If you only need Adminer for a one-off task, remove it immediately. It’s one file; you can upload it again in seconds.
7. Disable the “Permanent login” checkbox. In the source, you can set $adminer->permanentLogin = false; to prevent browsers from storing credentials in a cookie. I do this on shared machines.
8. Monitor access logs. If you must leave the file accessible, watch for 401 errors and suspicious IPs.
Advanced Usage and Hidden Tricks
Let’s go beyond the basics. These are things I’ve learned from years of casually abusing Adminer’s flexibility.
Using Adminer from the command line. You can’t directly run Adminer in CLI, but you can use php -S localhost:8080 in the directory containing the Adminer file, then open a browser to http://localhost:8080/a47b9c.php. This creates a temporary web server. Combine with a local .htpasswd-like setup, or just keep it local.
Docker integration. Create a Dockerfile:
FROM php:8.2-apache
COPY adminer-4.8.1.php /var/www/html/index.phpBuild and run:
docker build -t my-adminer .
docker run -d -p 8080:80 my-adminerNow you have a disposable Adminer container. Connect to databases on the host using host.docker.internal (Docker Desktop) or the host’s IP. For production-like stacks, I often add it as a service in a docker-compose.yml alongside the database, with internal networking and no exposed port, then access it via an SSH tunnel.
Plugin example: adding a “Run script” button. I wrote a plugin that adds a button to execute a predefined SQL script against the selected database. The plugin looks like:
class AdminerRunMyScript {
function head() {
echo script("
document.addEventListener('DOMContentLoaded', function() {
var btn = document.createElement('button');
btn.textContent = 'Run Cleanup';
btn.onclick = function() {
var ta = document.querySelector('textarea[name=\"query\"]');
if (ta) ta.value = 'CALL cleanup_old_sessions();';
document.querySelector('form input[type=submit]').click();
};
document.querySelector('#menu').appendChild(btn);
});
");
}
}You load it via plugins.php. The possibilities are wide. You can add custom export formats, hook into login to log accesses, or hide sensitive tables from the navigation. The plugin system is event-driven; check the official documentation for a list of methods you can override.
Editing connection presets. If you want to offer a dropdown with predefined servers without giving away passwords, you can encode passwords in the file. Edit the servers array:
function servers() {
return [
'Production (read-only)' => ['server' => 'db-prod.internal', 'username' => 'readonly', 'password' => 'secret'],
'Staging' => ['server' => 'db-staging.internal', 'username' => 'dev', 'password' => 'anothersecret'],
];
}I only do this inside a secured network or combined with IP restriction, never on a publicly exposed instance.
Using Adminer Editor as a client-facing data tool. Download the Editor variant (adminer-4.8.1-editor.php). Configure it to list only the tables you want, remove SQL command ability, and brand it with CSS. You can give a client a URL where they can search and edit their orders table without seeing database internals. I’ve done this for a small non-profit’s volunteer database and it cost me nothing.
Automating exports with wget/curl. Because Adminer uses standard form submissions, you can script a dump:
curl -s -b cookies.txt -c cookies.txt -d "auth[driver]=server&auth[server]=localhost&auth[username]=root&auth[password]=pass&auth[db]=mydb" -X POST https://example.com/secret.php -o /dev/null
curl -b cookies.txt -c cookies.txt -d "dump[format]=sql&dump[output]=text" https://example.com/secret.php?dump= -o backup.sqlIt’s hacky, but it works when you can’t use mysqldump due to hosting limits.
Real-World Stories (Because Anecdotes Beat Spec Sheets)
A developer I used to work with carried a USB stick with Adminer, a portable Firefox, and a few scripts. He traveled to client sites with spotty internet and often needed to massage a local database on a standalone Windows machine. He’d run PHP’s built-in server from the stick, open Adminer, and fix issues. No installation, no registry changes. That’s extreme portability.
Another time, a small e-commerce site’s admin panel broke after a framework update. The shop owner panicked because orders weren’t showing. I uploaded Adminer, joined the orders and products tables, confirmed the data was intact, and manually updated an order status. The store kept running while the dev team fixed the panel. If I’d waited for the full admin panel recovery, the owner would have lost sales.
I’ve also seen Adminer used in classroom settings. A bootcamp instructor would have students download the file to their localhost and immediately start exploring a pre-seeded SQLite database. No complex setup, no Docker required. Students learned SQL without wrestling with tools.
Where Adminer Will Not Help You
I want to be blunt. Adminer is a terrible choice for:
- Teams that need audit trails and role-based access for database management.
- Environments where non-technical staff must build reports without SQL.
- Projects requiring visual database design, ER diagrams, and schema synchronization.
- Situations where the organization mandates specific, approved client tools (like DBeaver, DataGrip, or Azure Data Studio) for compliance.
Also, if your database has hundreds of tables and you frequently need to navigate between them, Adminer’s simple left-hand list becomes a slog. The search box helps, but it’s not a faceted tree. I’ve used Adminer on databases with 400+ tables and it’s manageable, but I start wishing for a better navigation.
And if you’re working with large datasets (millions of rows), the default pagination of 30 rows and the absence of server-side scrolling can be slow. You can adjust the limit and write targeted queries, but it’s not a tool for browsing big data.
Spicy Opinions I Should Probably Keep to Myself
I think the database tool landscape has tilted too far toward “platforms” that want to be everything: monitoring, query analysis, user management, backup scheduling, and a live chat widget. I don’t want my database tool to have a notification bell. Adminer’s stubborn refusal to become a platform is its most underrated feature. It does one thing—let you talk to your database through a browser—and it does it without ceremony. That’s a virtue, not a limitation.
I’ve heard people call Adminer “outdated” because it lacks a REST API or a GraphQL playground. But you don’t manage databases with REST APIs; you manage them with SQL. If you need an API, build one. Adminer is a client, not a middleware layer. Let it be a client.
The absence of a visual query builder isn’t a flaw; it’s a nudge to learn SQL. I believe that if you’re managing databases, you should be comfortable writing JOINs and subqueries. The tool respects your intelligence enough not to hide the language behind drag-and-drop.
And yes, the default design is ugly. But I find that almost refreshing. It’s like a plain-text editor. No gradients trying to impress me. Just gray boxes and blue links that work. If I want prettiness, I’ll spend ten minutes writing a custom adminer.css that matches my terminal theme. Done.
Installing and Configuring Plugins (A Deeper Dive)
The plugin system is the secret weapon. You can find the official plugin list at adminer.org/plugins. Here are a few I use regularly:
- AdminerDumpJson: adds JSON export option.
- AdminerDumpZip: compresses exports.
- AdminerFrames: shows the interface in a frameset (yes, frames, for those who remember).
- AdminerEditTextarea: allows editing of
TEXTfields directly. - login-password-less: allows password-less login for local development.
- sql-log: logs all SQL queries to a file for debugging.
- tables-filter: provides a search box for tables if you have many.
To install a plugin, download its PHP file into a subdirectory, create a plugins.php that returns an array of class instances, and ensure the main Adminer file sees it. Example setup:
/secure/
a47b9c.php (main Adminer file)
plugins.php (plugin loader)
/plugins/
dump-json.php
dump-zip.php
tables-filter.phpIn plugins.php:
<?php
require_once 'plugins/dump-json.php';
require_once 'plugins/dump-zip.php';
require_once 'plugins/tables-filter.php';
return [
new AdminerDumpJson,
new AdminerDumpZip,
new AdminerTablesFilter,
];Some plugins need configuration. For sql-log, you might set a file path:
return [
new AdminerSqlLog('/tmp/adminer-queries.log'),
];Read each plugin’s source to understand its options.
Writing your own plugin: I’ve already shown a simple JavaScript injection. The real power comes from overriding methods like tableName(), databases(), navigation(), or dumpOutput(). You can hide tables, rename them in the UI, add custom export formats, or modify the SQL before execution. The Adminer source contains a class Adminer with all available hook methods. Your plugin can extend it and selectively override.
I built a plugin that added a “Clone row” button to the edit screen. Another one highlighted cells containing NULL with a light red background so they stood out during data review. It’s messy PHP, but it works. That’s the spirit.
Performance Notes and Tuning
Adminer itself isn’t the bottleneck—your database and PHP setup are. On a typical $5 VPS, pages render in under 200 milliseconds. The file size is small enough that opcache caches it effortlessly. If you’re seeing slowness, it’s usually the database executing a heavy query or the network latency.
For very large table structures (hundreds of columns), the column listing page might load slower because Adminer fetches table comments and collation details. You can speed it up by tweaking the limit parameter in URL or adjusting the $adminer->limit variable.
When exporting data, Adminer streams the output, so it can handle large dumps without memory exhaustion. But the browser might time out on a slow connection. For huge exports, I use CLI tools. For medium-sized dumps, Adminer’s ZIP plugin and direct download work fine.
Official Links and Resources
Bookmark these:
- Main site: https://www.adminer.org
- Download page (latest stable): https://www.adminer.org/#download
- Editor variant: available on the same page; look for
adminer-4.8.1-editor.php - GitHub repository: https://github.com/vrana/adminer (source, issues, pull requests)
- Plugin list: https://www.adminer.org/plugins/
- Documentation (basic but exists): https://www.adminer.org/en/ (click “Help” in the menu)
- CSS customization starter: https://www.adminer.org/en/design/ (explains how to override styles)
The tool is free, open-source (Apache 2.0 or GPL, depending on the file header; check the specific version). You can modify and redistribute within the license terms.
Putting It All Together: A Workflow for Different Levels
Junior dev on a local project: Install XAMPP or MAMP. Download Adminer into your htdocs. Bookmark http://localhost/adminer.php. Use it alongside the terminal. Practice SQL by writing in the command box. When you break things, fix them directly. This is how I got comfortable with ALTER TABLE without fear.
Freelancer managing multiple client sites: Keep a private Gist or snippet with a hardened Adminer configuration. For each client, you upload a renamed file, connect, do your task, and delete. Charge for the time you save not fighting with hosting control panels.
Sysadmin maintaining a fleet: Bundle Adminer with a simple Dockerfile and add it to your internal Docker registry. Deploy it as a service on your admin network, behind a VPN, with no public exposure. Pre-configure the server list for all your database clusters. Use HTTP Basic Auth and IP restrictions. Now you have a central, lightweight database jump box that loads in any browser without client software.
DBA evaluating tools: Give Adminer an honest test on a development database. Try writing your usual maintenance queries, check the execution time display, see if the export options meet your needs. Compare with your heavy client. You might keep Adminer as a backup or for quick lookups on the go. The SQL autocomplete is minimal—it just remembers table and column names from the current session—but you’ll miss it when you’re in a terminal-only situation.
Final Thoughts (No Sunny Predictions, Just What I’ve Observed)
Adminer has been around for almost 20 years without changing its core personality. It’s still one file. It still loads fast. It still requires you to know SQL to get the most out of it. I find that steadiness comforting in a world where software bloats monthly. I don’t want my database tool to get “AI-powered insights” or push notifications.
Will Adminer ever replace your $300 SQL IDE? Probably not. But it will be there when you need to flip a bit in a remote database at 2 a.m., and that’s worth a lot. I keep the latest version in my toolbox, and I recommend you do too. If the interface bothers you, style it. If you need a feature, write a plugin. If you don’t need it, delete it. That’s the freedom a single-file tool gives you.
How to get a free hosting account to install Adminer?
Free Hosting and Adminer: A Hands-On Tutorial
You don’t need a paid server to try this. I’ve set up Adminer on free PHP hosting more times than I can count—for quick demos, teaching, or just testing a connection remotely without touching my own machines. Here’s how to do it with AlwaysData, my go‑to free host. They give you 100 MB of disk, PHP (with most database extensions), and one free MySQL/PostgreSQL database. No ads, no forced upgrades. Other options exist (InfinityFree, 000webhost), but AlwaysData’s clean interface and European hosting win for me.
I’ll walk you through the whole thing. Takes about ten minutes.
Step 1: Sign up for a free AlwaysData account
Go to alwaysdata.com and click “Sign up.” Use a real email; they’ll send a verification link. Pick a username—this becomes your subdomain: username.alwaysdata.net. The free plan includes 100 MB of space, 1 database, and unlimited sites (all under that same subdomain). After confirming your email, log in to the administration panel.
Step 2: Create a database
In the AlwaysData dashboard, look for “Databases” in the sidebar. Click “Add a database.” Choose MySQL or PostgreSQL (I’ll use MySQL for this example). Set a database name, user, and password. Write them down. Wait a few seconds for the database to spin up. You’ll see the connection details: host is usually mysql-username.alwaysdata.net or just localhost—the panel tells you. Note the exact host.
Step 3: Get Adminer onto your hosting space
Grab the latest Adminer PHP file from adminer.org. Rename it to something less obvious—maybe dbx49.php. Back in the AlwaysData panel, go to “Files” (or use the “Web FTP” button). You’ll land in your site’s document root (/www/). Upload the renamed file. If you prefer SFTP, the dashboard shows your SSH/SFTP credentials (yes, they give you SSH even on the free plan). Either way, you now have a file at https://username.alwaysdata.net/dbx49.php.
Step 4: Log into Adminer and connect
Open https://username.alwaysdata.net/dbx49.php in your browser. You’ll see Adminer’s login screen. For the database system, choose “MySQL.” Fill in:
- Server: the host name from step 2 (e.g.,
mysql-username.alwaysdata.net). - Username: the database user you created.
- Password: that user’s password.
- Database: leave blank to see all, or type the database name.
Click “Login.” You’re in. You can now create tables, run queries, import and export data—the whole Adminer experience, from a free host.
Step 5: A few critical security notes
Free hosting means you share resources with strangers. Don’t leave Adminer online unless you really need it.
- Remove the file after use. One-click delete from the AlwaysData file manager. You can re‑upload it in seconds next time.
- If you must keep it, rename it again to a long, random string. Bots do scan for
adminer.php. - Enable AlwaysData’s “Protection” on the directory. In the “Web” → “Sites” section, you can add password protection (HTTP Basic Auth) to a path—same idea as earlier in the article. Use it.
- Never use the database’s root credentials. AlwaysData’s database user you created is limited to that one database; that’s enough.
Other free hosts (and why I still recommend AlwaysData)
InfinityFree gives more space and unlimited bandwidth, but their PHP extension set is quirky; sometimes PDO modules are missing. 000webhost (Hostinger’s free arm) works but puts a sleep timer on your site and injects analytics. AlwaysData, while limited to 100 MB, gives you proper SSH, cron jobs, and a clean environment. That’s why I use it for demos.
If your Adminer file is too large? The single file is around 500 KB. You have 100 MB total, so you’re fine. Just don’t upload giant SQL dumps alongside it.
Testing on your local machine first? Skip the host entirely. Run php -S localhost:8080 in the folder with dbx49.php. Open http://localhost:8080/dbx49.php. Connect to your local database. The same steps, minus any internet. I do this constantly during development.
That’s it. With a free account and a single file, you’ve got a fully portable database client you can reach from anywhere. No excuses now.