36 posts tagged with "metron"

Following up on the v1.1 release from July, MetronInfo v1.2 is out. This release is focused on the Series element, adding three new optional elements and loosening the restrictions on language codes.

Over the last week I've received quite a few e-mails from app developers, comic shops, and other businesses that want to use the Metron API in their products. Most of them ask the same questions: whether commercial use is allowed, whether one account can serve many users, how to handle attribution, and what the situation is with cover images. Here are the answers in one place.

Up to now, the only way to authenticate against the Metron API was HTTP Basic Auth with your account username and password — meaning every script or third-party tool you connected got a copy of your actual login credentials. Today that changes: you can now generate revocable API tokens and use them instead, without giving up Basic Auth.

A quick follow-up to the v1.0 announcement from two years ago: MetronInfo v1.1 is out, adding two new optional elements that came out of feedback since the initial release.

Back when we added Open Collective support in December 2024, I mentioned that a paid tier for a higher API rate limit wasn't something I was planning on — but that it might be worth revisiting someday if there was enough demand. Then in March we had to cut the daily limit from 10,000 to 5,000 requests due to server load, with a promise to look at restoring it if donations picked up. Well, someday is here: donors to the project now automatically get an elevated daily API rate limit, no paid subscription plan required — just a donation through Open Collective.

As mentioned in our February 2026 update, we have been dealing with increased server load due to the growth in API usage. We have made the decision to reduce the API rate limits effective immediately.

The new limits are:

• 20 requests per minute (down from 30)
• 5,000 requests per day (down from 10,000)

We know this is not ideal, and we're sorry for any inconvenience this may cause. If we receive enough donations in the future to cover the cost of a server upgrade, we would look at restoring the daily limit back to 10,000 requests per day.

Updated Client Libraries​

New releases of our client libraries have been published that reflect these updated rate limits:

• Mokkari v3.20.0 — the Python wrapper for the Metron API has been updated with the new rate limit configuration.
• Metron-Tagger v4.9.0 — updated to use the latest version of Mokkari, picking up the new rate limits automatically.

If you use either of these tools, we recommend upgrading to the latest version.

Note for API Consumers​

If you have written software that directly consumes the Metron API, please ensure your code correctly handles HTTP 429 (Too Many Requests) responses. When this status code is returned, the response will include a Retry-After header indicating how many seconds to wait before retrying. Your application should respect this header and delay its next request accordingly, rather than continuing to hammer the server. Failing to handle this gracefully may result in your requests being blocked.

If you have any questions or suggestions, don't hesitate to e-mail me or ping me on Matrix.

Monthly Statistics​

During February the Metron Project added the following to its database:

• Users: 152
• Issues: 1,357
• Creators: 246
• Characters: 678

Thanks to everyone that contributed!

API Usage​

Over the last 6 months, API usage has seen a significant increase — which is great! However, we are now at a point where our current server capacity is being strained.

Jonas Stendahl and I have landed some optimizations in the site's code, but they only go so far in relieving the pressure.

That leaves us with two options:

1. Upgrade our server capacity — an additional $27–$43/month depending on the CPU tier selected.
2. Reduce the daily rate-limit from 10,000 requests to something like 5,000.

Option #1 is clearly preferable, but we currently don't receive enough donations to cover the extra cost. That means we will likely need to reduce the daily rate-limit in the very near future, and we'll post an announcement here when that happens.

If you have other ideas or suggestions, please reach out!

Website Updates​

Performance Improvements​

Several changes were made to improve API and database query performance.

• API query optimization: Refactored multiple API endpoint viewsets to reduce unnecessary database queries through better use of select_related and prefetch_related.
• Additional database indexes: Added missing indexes on several models (Publisher, Series, Team, Universe) and their related issue querysets, which should speed up common lookups. (jyggen)
• Fixed paginated Series queryset warning: Added explicit order_by() to SeriesViewSet and the publisher series-list action to resolve a UnorderedObjectListWarning that could surface during pagination.

API Enhancements​

• Conditional request support: The API now supports HTTP conditional requests using ETag and Last-Modified headers. Clients can send If-None-Match or If-Modified-Since headers to avoid re-downloading unchanged data, saving bandwidth. (jyggen)
• Read dates in collection API: The collection list endpoint now includes read_dates data, giving API consumers access to reading history information directly from the list view.

Collection & Reading History​

• Reading history charts: The Collection Statistics page now includes daily (last 30 days) and monthly (last 12 months) column charts showing reading activity over time. Days with no reading activity are included in the daily chart.
• Refined badge display logic: The read-count badge is now only shown when an issue has been read multiple times on the same calendar day, avoiding misleading counts from reads on different days.

User Interface Fixes​

• ESC key closes cover modal: On issue detail pages, pressing the Escape key now closes the cover image modal, matching standard UX conventions.
• Variant formset display tweaks: Minor layout improvements to the variant issue formset to better display its fields.
• User template improvements for editors: The user profile template now shows additional information for editors.
• Series form validation fix: Handled a case where a missing series type would cause an unhandled error during form validation.

Other​

• Django 5.2.11 (#454): Updated to the latest Django 5.2 patch release.

Mokkari Updates​

The following changes made to Mokkari, the Python wrapper for the Metron API, over the past month:

Added if_modified_since parameter to detail endpoints​

All the detail methods (arc, character, creator, imprint, issue, publisher, series, team, universe, reading_list, and collection) now accept an optional if_modified_since datetime parameter. When provided, the request includes an If-Modified-Since HTTP header (formatted per RFC 7231) and returns None on a 304 Not Modified response — useful for efficiently detecting whether a resource has changed since you last fetched it. Naive datetimes are treated as UTC, and non-UTC datetimes are automatically converted before the header is sent.

Added Read Dates to CollectionList schema​

The collection schemas have been updated to match the latest Metron API:

• A new ReadDate model was added with id, read_date, and created_on fields.
• read_dates and read_count fields were added to CollectionList and CollectionRead.
• The date_read field type in CollectionRead was changed from date to datetime to align with the API's date-time format.

Migrated to PyrateLimiter 4.x​

The rate-limiting implementation was updated for the breaking changes in pyrate-limiter 4.0:

• Removed the now-deleted BucketFullException and LimiterDelayException imports.
• Simplified Limiter construction.
• Rewrote _check_rate_limit() to use the boolean return value of try_acquire(blocking=False) instead of catching exceptions.

Desaad Update​

Here's a roundup of changes shipped to Desaad over the past month.

Reading History Import​

The import_reading_status management command was upgraded: it now imports reading history dates from Metron, not just reading status. A new ReadDate model was added to store the actual date an issue was read, and the UserStatsView was updated to use these dates for reading activity stats. Previously, stats reflected the import timestamp rather than when issues were actually read.

Importer: Require External IDs​

The comic importer was tightened up to require an external ID when creating characters, teams, universes, arcs, locations, genres, and creators. Previously, the importer would fall back to name-based lookups and create records without a verified external ID, leading to potential unverified duplicates. This change simplifies the importer significantly and ensures all entities can be reliably matched against a metadata source.

Reader UX: Double-Tap Confirmation​

The comic reader's Prev Issue, Next Issue, and Close buttons now require a double-tap to activate. On the first tap, the button turns yellow and prompts "Tap again"; a second tap within 2 seconds proceeds with navigation. Otherwise, the button resets. This prevents accidental navigation away from your current reading position.

Infrastructure Updates​

• Python 3.14: The container image was updated to use Python 3.14.
• Timezone via environment variable: The Django timezone setting is now configurable via an environment variable. Missing DB_* variables were also documented in the README.
• Dependency updates: Project dependencies were refreshed across the board.

OpenCollective​

A huge thank you to everyone who has contributed to our Open Collective! Your support makes a real difference in keeping the Metron Project running and growing.

What Your Contributions Support​

Funds from Open Collective go directly toward:

• Server hosting costs - Keeping the Metron website and API available
• Domain registration - Annual domain name renewals
• Future capacity increases - Scaling resources as the database and user base grows

All expenses are transparent and publicly viewable on our Open Collective page, so you can see exactly where every dollar goes.

Support the Project​

If you'd like to help keep the lights on and support continued development, contributions of any size are appreciated and help ensure Metron remains a free resource for the comic book community.

Anyway, that's everything for this month! Take care.

Monthly Statistics​

During January the Metron Project added the following to its database:

• Users: 169
• Issues: 2,238
• Creators: 395
• Characters: 1,430

Thanks to everyone that contributed!

Website Updates​

New Features​

Scrobble API Support

A new /scrobble endpoint allows users to quickly mark issues as read via the API with optional rating and timestamp. This enables integration with third-party reading apps and automated tracking workflows. The date_read field was migrated from a date to datetime for more precise tracking.

Reading History

Users can now view their reading history in a timeline layout with daily grouping. Recent reading activity also appears on user profile pages.

Multiple Read Dates

Collection items now support tracking multiple read dates, since comic issues are often re-read over time. The UI includes HTMX-powered controls for adding and removing read dates directly from the detail page.

Community View

User profiles now use username-based URLs (/accounts/username/) instead of numeric IDs. A new user list view with search functionality was added, making it easier to find and view other community members.

Improvements​

HTMX Migration

Significant portions of the frontend JavaScript have been replaced with HTMX:

• Global HTMX import in the base template
• Navbar burger menu converted to HTMX
• File upload handlers simplified with inline onchange attributes
• Notification dismissals now use HTMX
• Modal dialogs for read date deletion converted to HTMX
• Removed several legacy JavaScript files (jquery.formset.js, bulma-modal.js, bulma-navbar-burger.js, bulma-notifications.js)

Auto-Dismissing Notifications

Non-error notifications now automatically disappear after 5 seconds. Error messages remain visible until manually dismissed.

Issue Autocomplete Search

The issue autocomplete now supports more flexible searching:

• Search terms can be in any order ("Spider Amazing" matches "Amazing Spider-Man")
• Series year filtering using parentheses (e.g., "Speed Racer (2025) #4")

Email Compatibility for Account Activation

Updated how Metron sends account activation emails to ensure they display correctly across all major email clients.

The changes include:

• Multipart emails: Activation emails now send both HTML and plain text versions, ensuring users can read them regardless of their email client settings
• Universal styling: Replaced CSS stylesheets with inline styles, since Gmail and Outlook strip CSS from the <head> section
• Table-based layout: Switched from div-based layouts to tables for consistent rendering in older email clients
• Better color support: Removed CSS gradients in favor of solid colors for Outlook compatibility
• Web-safe fonts: Now using Arial and Helvetica instead of system fonts for cross-platform consistency

These updates should ensure new users have a smooth onboarding experience, regardless of whether they use Gmail, Outlook, Apple Mail, or any other email client.

Bug Fixes​

• Fixed duplicate issue creation race condition—users now see a friendly error instead of a 500 error
• Fixed SlugRedirectView when requesting non-existent items
• Fixed success message formatting in user account activation
• Fixed sequential read date deletion (HTMX event handlers now reinitialize properly after content swaps)

Infrastructure​

• Updated to Django 5.2.10
• Removed request for GitHub stars from the welcome flow

Desaad Updates​

The following changes were made to Desaad.

Scrobbling to Metron​

Issue scrobbling was added this month, and more information on it can be found in this blog post.

Database Migration to PostgreSQL​

The application has migrated from SQLite to PostgreSQL. This followed an initial attempt to improve SQLite concurrency with WAL mode and retry logic, but PostgreSQL proved to be a better fit for handling concurrent operations during comic imports while the web server is running.

Reader Improvements​

The comic reader received several updates:

• Added previous/next issue navigation for reading through a series
• Added gesture hints overlay to help users discover touch controls
• Implemented browser caching for page images with proper HTTP cache headers (ETag, Cache-Control)
• Improved performance by using the stored page count from the database rather than reading from the archive each time
• Added customizable auto-hide delay for reader controls

After testing both approaches, the reader reverted to using base64 image data instead of image URLs, as this provided a better reading experience.

Background Task Processing​

The app now uses Django 6.0's Tasks framework with django-tasks[rq] for several operations:

• Reading list imports now run asynchronously with status polling via HTMX
• Cover extraction is deferred to a background queue, making initial imports faster
• Missing reading list items are automatically linked when matching issues are imported

Metron Integration​

A new import_reading_status management command allows users to sync their reading history from their Metron collection. This imports completion status and ratings for issues that match by Metron ID. Currently, it only imports the read status, but in the near future it will add the dates the issues were read on also.

HTMX Adoption​

Replaced JavaScript with HTMX in several places:

• Notification dismiss buttons
• Reading list detail page (delete modal, hide/show missing toggle)
• Navbar burger menu

Other Changes​

• Added sorl-thumbnail with Redis cache backend for cover images
• Added cover images to the series list view
• Added a home view showing next unread issues for started series
• Added completion indicators to reading list overview
• Added django-debug-toolbar for development
• Various container and deployment fixes

OpenCollective​

A huge thank you to everyone who has contributed to our Open Collective! Your support makes a real difference in keeping the Metron Project running and growing.

What Your Contributions Support​

Funds from Open Collective go directly toward:

• Server hosting costs - Keeping the Metron website and API available
• Domain registration - Annual domain name renewals
• Future capacity increases - Scaling resources as the database and user base grows

All expenses are transparent and publicly viewable on our Open Collective page, so you can see exactly where every dollar goes.

Support the Project​

If you'd like to help keep the lights on and support continued development, contributions of any size are appreciated and help ensure Metron remains a free resource for the comic book community.

Anyway, that's everything for this month! Take care.

Introducing Collection Scrobbling​

We've added a new scrobble endpoint to Metron that makes tracking your comic reading progress more convenient.

What is Scrobbling?​

Scrobbling is a quick way to mark an issue as read via the API. The term comes from music services like Last.fm, where it refers to automatically tracking what you're listening to. For Metron, it means you can instantly log that you've finished reading a comic issue without navigating through the web interface.

How It Works​

The new /api/collection/scrobble/ endpoint accepts a simple POST request with an issue ID. When you scrobble an issue, Metron will:

• Mark the issue as read in your collection
• Record the exact date and time you finished it
• Optionally save a star rating (1-5)
• Automatically add the issue to your collection if it's not already there

If the issue doesn't exist in your collection yet, scrobbling creates a new collection item with reasonable defaults (digital format, quantity of 1). If it's already in your collection, the endpoint just updates the read status and timestamp.

Why We Built This​

The web interface works fine for managing your collection, but marking issues as read can feel cumbersome when you're actively reading. You have to navigate to the right page, find the issue, click edit, check the box, and save. That's several steps just to record something simple.

Scrobbling reduces this to a single API call. This opens up possibilities for:

• Browser extensions that add a "mark as read" button to digital comic readers
• Mobile apps that track reading activity in the background
• Import scripts that bring in reading history from other services
• Reading tracker tools that focus specifically on logging your progress. If you are using Dessad this feature has already been added.

Technical Changes​

To support more precise tracking, we migrated the date_read field from DateField to DateTimeField. This means you can now track exactly when you finished reading an issue, not just which day. All existing data was preserved during the migration.

Reading History​

Along with scrobbling, we added a reading history view that displays your recently-read comics in a timeline format. You can see:

• When you read each issue (with exact timestamps)
• Cover thumbnails for quick visual reference
• Format badges showing whether you read print or digital
• Your star ratings

The full reading history is available at /collection/history/, and your user profile now shows your 10 most recent reads.

Getting Started​

To scrobble an issue, make a POST request to /api/collection/scrobble/:

{
  "issue_id": 12345,
  "date_read": "2026-01-08T14:30:00Z",
  "rating": 4
}

The date_read and rating fields are optional. If you omit date_read, it defaults to the current timestamp.

Authentication is required (Basic Auth or session), and the endpoint respects collection privacy—you can only scrobble to your own collection.

What's Next​

The scrobble endpoint provides a foundation for better reading tracking. We'd like to see what tools the community builds with it. If you create a browser extension, mobile app, or other integration, let us know.

For complete API documentation, see the User Collection Documentation.

Monthly Statistics​

During December the Metron Project added the following to its database:

• Users: 99
• Issues: 1,668
• Creators: 208
• Characters: 1,176

Thanks to everyone that contributed!

Website Development​

🎉 New Feature: User Collections​

This month I added a User Collections system that lets you track your personal comic book collection. You can manage your collection by adding or removing issues, mark things as read, and track comic condition using the CGC grading scale (0.5 to 10.0). The grading system supports professional grading companies like CGC, CBCS, and PGX, as well as user-assessed grades for raw comics.

There's also a star rating system (1-5 stars) for rating issues in your collection, format tracking for print and digital copies, and bulk operations to add entire series runs at once. If you're trying to complete runs, there's a missing issues tracker that shows you which issues you need and displays completion percentages for each series.

The feature includes collection statistics with visual charts, advanced filtering options to search by series, publisher, format, read status, grade, and more. There are also read-only API endpoints for accessing your collection data and statistics, along with documentation to help you get started.

📚 Reading Lists Enhancements​

Reading lists got some updates this month. You can now tag issues as Prologue, Core Issue, Tie-In, or Epilogue, with inline editing and visual badges to make it easier to see what's what. I also added a 5-star rating system for public reading lists, so you can see average ratings and filter lists by minimum rating.

There's also story arc integration that lets you add all issues from a story arc to a reading list in one go, which should save some time. I created a "reading list editor" group for managing Metron's curated lists - this allows trusted users to help curate without needing full staff privileges. If you're interested in being part of this group, just let me know.

The reading list API now supports browsing and retrieving lists with paginated results (50 items per page) and filtering options.

🔍 Search & Filtering Overhaul​

I spent some time improving the search functionality across the site. Series lists now support multi-word search with filters for type, publisher, imprint, year range, status, and volume. Issue lists have quick search with advanced filters for series info, dates, and IDs. Reading lists can be searched by name, creator, attribution source, and privacy status. User collections have quick search across series names and notes with multi-field filtering.

All the search interfaces now have collapsible advanced filter sections, preserve your filter state, show active filter indicators, and have better empty states. I tried to keep the UI patterns consistent across all of them.

🐛 Bug Fixes​

Week Views Date Calculation Fix (#437)​

Fixed a bug where WeekList, NextWeekList, and FutureList views were using class-level date calculations evaluated at import time. This meant the views would always show the same week (from when the server started) instead of updating dynamically. I moved the date calculations to per-request methods and switched to precise date range queries to fix this.

📱 Mobile Improvements​

Fixed a few mobile-specific issues this month: filter buttons now work properly on mobile devices, improved the home page responsiveness, fixed layout issues in home.html, and cleaned up button layouts across collection and reading list views.

🎨 UI/UX Enhancements​

Added a Reading List & Collections section to the home page, made the first information card full width, and improved the overall layout for better visual hierarchy. I also spent time optimizing database queries - reading list detail views went from around 20 queries down to 4-6 by using better prefetching and annotation strategies. Collection detail views now show cover images and descriptions with lazy loading.

🔒 Security & Validation​

Improved permission checks across reading list operations.

🔧 Technical Improvements​

Upgraded to Django 5.2.9 and added documentation for User Collections and Reading Lists, including user guides, technical documentation for developers, and API documentation. I also refactored and simplified some views with better inheritance patterns.

Looking Ahead​

Now that User Collections is up and running and Reading Lists have been improved, the plan is to refine these features based on user feedback and explore additional integration opportunities.

Desaad: A Comic Book Library Management System​

What is Desaad?​

Desaad is a self-hosted, web-based comic book library manager and reader built with Django that I've been working on over the past week or so. I created it to test and plan features for Metron that might be useful for other comic servers.

Key Features​

Library Management​

Desaad imports CBZ, CBR, and PDF comic archives and automatically pulls metadata from MetronInfo.xml files - things like series information, publishers, creators, characters, teams, universes, and story arcs. I'm not planning to add ComicInfo.xml support, since there are a lot of comic servers that already do.

It uses Darkseid for handling comic archives and extracting metadata.

Built-in Web Reader​

The web reader uses HTMX and automatically saves your reading position and progress, so you can pick up where you left off.

Reading Lists​

You can import reading lists from Metron using the API. The feature automatically tracks which issues are in your library and shows you which ones you're missing.

OPDS 1.2 Catalog Support​

You can access your comic library from mobile devices and e-readers using OPDS-compatible apps like Chunky Comic Reader (iOS), Panels (iOS), or Challenger Comics Viewer (Android).

I tried testing it with the Challenger app, but their OPDS support doesn't seem to work and is still marked as Beta. If anyone wants to test with Chunky or Panels, I'd appreciate hearing how it goes.

Auto-Import Functionality​

There's an import management command that you can run manually or set up to watch a directory for new comics.

I haven't optimized it much yet - the most expensive part is cover extraction, which I'll probably move to a background task at some point. I deployed it on a spare GMKtec NucBox G3 I had, and it took about 3 hours to import around 65,000 comics. Once I move cover extraction to a background task, I should be able to get that down to 1-2 hours.

Technical Foundation​

Desaad is built on Django 6.0 with SQLite for simplicity (though I'll probably switch to PostgreSQL at some point since SQLite has some performance limitations and missing features). The frontend uses the Bulma CSS framework with HTMX, and comic processing is handled by the Darkseid library. It's container-ready with Podman support and systemd integration.

It requires Python 3.13+ and uses the uv package manager for dependency management.

Important Considerations​

A few things to keep in mind about Desaad:

1. Single Metadata Source: It assumes all your comics use metadata from a single source (Metron, Comic Vine, etc.). Mixed metadata sources aren't supported.

2. MetronInfo.xml Format: Only supports the MetronInfo.xml metadata specification. Your comics need metadata written by software that implements this spec.

3. Under Active Development: The project is still under construction and not ready for production use. Features and APIs will change.

Who Should Use Desaad?​

Desaad might be a good fit if you're a developer or tester who prefers browser-based reading and wants to see possible new features like scrobbling. It works best if your collection uses metadata from a single source (Metron, Comic Vine, or Grand Comics Database). If your collection has mixed metadata from multiple sources, Desaad probably isn't the right tool for you.

Getting Started​

Setting up Desaad is pretty straightforward:

# Clone the repository
git clone https://codeberg.org/bpepple/desaad.git
cd desaad

# Configure environment
cp .env.example .env
# Edit .env with your settings

# Install dependencies and setup
uv sync
uv run python manage.py migrate
uv run python manage.py createsuperuser
uv run python manage.py collectstatic

# Run the development server
uv run python manage.py runserver

For production deployments, there are Podman compose configurations with systemd service integration.

Container Deployment​

If you're using Fedora Linux, the included Podman configuration should make deployment simple. It should work on other systems running Podman too, but I haven't tested that yet. To get started:

# Build and start
podman-compose up -d

# Create admin user
podman-compose exec web python manage.py createsuperuser

# Import comics
podman-compose exec web python manage.py import_comics

The application will be available at http://localhost:9000.

There's more information in the project's README.md, including how to create systemd service files.

OpenCollective​

A huge thank you to everyone who has contributed to our Open Collective! Your support makes a real difference in keeping the Metron Project running and growing.

What Your Contributions Support​

Funds from Open Collective go directly toward:

• Server hosting costs - Keeping the Metron website and API available
• Domain registration - Annual domain name renewals
• Future capacity increases - Scaling resources as the database and user base grows

All expenses are transparent and publicly viewable on our Open Collective page, so you can see exactly where every dollar goes.

Support the Project​

If you'd like to help keep the lights on and support continued development, contributions of any size are appreciated and help ensure Metron remains a free resource for the comic book community.

Anyway, that's everything for this month! Take care.