Diva Scans Not Working? The JSON Error Explained

🐛 Issue #16693 was a duplicate, not the first failure report: an earlier May 31 ticket had already linked the breakage to a redesigned website and a domain change.
🔧 The failure signature was a JSON decoding exception, which is consistent with an extension expecting one response shape while the website or API returns another.
📦 The repository now lists the extension at version 1.4.25, while the May 31 report referenced 1.4.21 and the June 9 report referenced 1.4.23.
🧩 Current source code uses direct API routes, accepts more than one JSON envelope shape, and adds defensive parsing and image URL cleanup rather than relying on one fragile page structure.
📱 For users, the practical decision is to update Mihon and the extension first, then test WebView, clear WebView state, capture logs, and migrate only if the source still fails.

Diva scans stopped working for Mihon users because the source website changed its domain, page structure, and data responses faster than the extension parser could adapt. The clearest clue is that issue #16693 was not the first report: a May 31 ticket had already tied the breakage to a redesigned site and a new domain (Alexxlx121, 2026).

The June 13 issue reported an ‘unexpected json decoding exception’ on Mihon 0.19.9 and Android 13. GitHub marked that report as a duplicate. A separate June 9 ticket had already reported a JsonDecodingException on extension version 1.4.23, while the earlier May ticket referenced version 1.4.21. That sequence matters because it points away from a single phone problem and toward a source-integration problem (Mmmmmmmmari, 2026; dmcspop12, 2026).

The technical story is easier to understand if we separate the visible website from the data contract used by the extension. Readers who want that foundation can review how APIs exchange JSON between apps and websites. In this case, the current repository shows a more defensive implementation that calls API endpoints directly, handles multiple response shapes, and cleans image URLs. Our desk did not run the extension on a physical Android device, so this article does not claim that every current title, chapter, or paid-content path works. It does show what broke, what maintainers changed, and what users can check without guessing.

What the GitHub Record Actually Shows

The incident began before issue #16693. On May 31, 2026, issue #16352 said Diva Scans had moved to divascans.org and had ‘completely redesigned the website,’ leaving old paths unusable. GitHub tagged that ticket as both a domain change and a valid extension problem. That is the strongest early evidence because it identifies a structural change, not just a generic app crash (Alexxlx121, 2026).

On June 5, pull request #16478 proposed a broader repair. Its summary described bypassing fragile Next.js hydration parsing, extracting raw JSON for manga details and chapter lists, decoding proxied image URLs, and adding better filter behavior. The pull request was still shown as open in our review, so it should not be described as a single merged fix. It is still valuable evidence of the failure modes maintainers were trying to solve (SOUMYAR10, 2026).

Then came repeated user reports. Issue #16586 on June 9 named a JsonDecodingException on version 1.4.23. Issue #16693 on June 13 reported the same class of error and was marked duplicate. The later ticket also contains a small inconsistency: its device field says Mihon 0.19.9, while the acknowledgement text says the app had been updated to 0.19.3. That mismatch does not explain the source failure, but it is a reminder that issue-form checkboxes are not always precise evidence of the installed environment.

By August 24, the live Keiyoushi extension index listed Tachiyomi: Diva Scans version 1.4.25. The live site was reachable at divascans.org, and divatoon.com redirected there during our check. That does not prove the integration is permanently stable. It does show that both the website and extension continued moving after the June reports.

Date	Evidence	What it tells us
May 31, 2026	Issue #16352, extension 1.4.21	Website redesign and new domain broke existing paths.
June 5, 2026	PR #16478	Maintainer work targeted Next.js parsing, JSON extraction, image URLs, and filters.
June 9, 2026	Issue #16586, extension 1.4.23	JsonDecodingException persisted for users after the first report.
June 13, 2026	Issue #16693, Mihon 0.19.9	Same error pattern was reported again and marked duplicate.
August 5, 2026	Mihon v0.20.4	The app itself had advanced beyond the version used in the June ticket.
August 24, 2026	Extension index shows 1.4.25	The source package had also advanced beyond the reported versions.

Why a JSON Decoding Exception Appeared

A JSON decoding exception usually means the client received data that did not match the structure its parser expected. JSON itself is only a text format for structured data. The failure happens when code expects one field type, nesting pattern, or envelope and gets something else, or when it receives non-JSON content where JSON was expected (Bray, 2017).

The current source makes that diagnosis unusually visible. Its catalog layer calls `/api/series` and `/api/search`. When reading a manga list, it first tries to parse the response as a bare list. If that fails, it tries a wrapper object. If both fail, it returns an empty page instead of throwing the same fatal parsing path. The code comment explicitly notes that the API may return either a bare array or an object with the list nested under different keys (Keiyoushi, 2026).

That defensive pattern is exactly what durable API design and predictable error handling recommends in a broader engineering context: consumers need predictable contracts, but real clients also need graceful failure paths when upstream behavior changes. The trade-off is visibility. Returning an empty list can prevent a crash, yet it can also make a bad upstream response look like ‘no results.’ Good diagnostics still matter.

The source also contains Next.js extraction logic for series pages and a utility that rewrites proxied image URLs toward the media domain. Those details line up with the June pull request’s description of hydration-data and image-loading problems. In other words, the exception was part of a wider compatibility break, not a standalone JSON library bug.

What Changed in the Extension

The most important shift is architectural. Older scraping extensions often depend heavily on stable HTML selectors or embedded page data. The current implementation uses a direct API catalog and search layer, while still keeping fallbacks for page-level data. That reduces dependence on one visible layout, although it does not eliminate dependence on the site’s private contract.

Our desk review found three resilience choices worth noting. First, list parsing accepts multiple JSON shapes. Second, series extraction is wrapped so a failure can return a null result rather than crash the whole flow. Third, image cleanup decodes proxy URLs and normalizes media-host paths. These are targeted responses to the exact classes of breakage described in the issue and pull request history.

There is also a product-level change: the source exposes a preference to show paid chapters, while warning that those chapters cannot be read natively in the app. The live website displays coin-priced and unlocked chapter states, so the extension is operating against a service that now mixes public and gated content. That adds more states for a third-party client to interpret correctly.

This maintenance pattern is common in unofficial Android clients. our Kuroba Android guide explains the same dependency from another angle: when a third-party client relies on a website it does not control, site structure, anti-bot systems, or domain changes can break the app until maintainers adapt.

Integration layer	Earlier failure risk	Current defensive behavior	Remaining trade-off
Catalog/search data	One unexpected JSON shape can fail parsing	Attempts a list shape, then a response envelope	Silent empty results can hide bad upstream data
Series details	Next.js page-data changes break extraction	Uses Next.js extraction with guarded parsing	Still depends on private page data structure
Images	Proxy and CDN paths can return 404s	Decodes proxy URLs and normalizes media host paths	Future CDN changes can break rules again
Paid chapters	Locked states can be misread as normal chapters	User preference separates paid visibility	Native reading remains unavailable for paid content

The Safest Troubleshooting Order for Mihon Users

The first move should be version alignment, not repeated reinstalls. The June 13 report used Mihon 0.19.9, while the latest GitHub release we verified was Mihon 0.20.4, published August 5, 2026. The Keiyoushi index also showed extension version 1.4.25. If either component is behind, update it before drawing conclusions from an old error message.

Second, open the source in WebView. Mihon’s official troubleshooting guide tells users to open Browse, select the source, use the WebView icon, and complete a CAPTCHA if one appears. If the site itself does not load normally there, the extension may be blocked by a site-side or browser-layer problem rather than a parsing defect (Mihon, 2026).

Third, clear cookies and WebView data if the browser state looks stale. Mihon’s documentation specifically recommends More > Settings > Advanced > Clear cookies and Clear WebView data. It also recommends keeping Android System WebView or Google Chrome current and warns that non-standard WebView implementations can cause malfunctions or crashes (Mihon, 2026).

Fourth, capture evidence before changing sources. Mihon provides a Dump crash logs option and points advanced users toward Logcat for abnormal behavior. A log that shows an HTTP status, response body problem, or serialization stack trace is far more useful than ‘it does not work.’ For APK update and signature problems, our Seal APK guide provides a broader source-verification model that also applies to extension packages: verify the original repository, version, and update path before installing files from mirrors.

Finally, migrate only when the source remains unusable after updates and WebView checks. Migration preserves reading continuity, but it does not repair the source. Treat it as a continuity option, not a technical fix.

Step	Do this	What the result means
1	Update Mihon and the Diva Scans extension	Rules out already-fixed compatibility code.
2	Open the source in WebView	Shows whether the website itself is reachable and whether CAPTCHA or anti-bot checks intervene.
3	Clear cookies and WebView data	Removes stale login, redirect, or verification state.
4	Update Android System WebView or Chrome	Rules out an outdated embedded browser component.
5	Dump crash logs or capture Logcat	Turns a vague failure into a reproducible technical report.
6	Migrate if the source remains broken	Protects reading continuity while maintainers investigate.

Three Findings Most Quick Fix Guides Miss

A duplicate issue is evidence, not noise

When two users report the same JsonDecodingException within days and an older ticket already documents a site redesign, the duplicate label strengthens the diagnosis. It shows the problem was reproducible across more than one user report. The useful editorial question is not why the second user failed to search perfectly. It is what the repeated signature says about the integration boundary.

The current parser trades crashes for ambiguity

Defensive parsing is better for users than a hard serialization exception, but a fallback that returns an empty list can make an upstream contract failure look like a quiet content gap. Maintainers need logs or telemetry-quality issue reports to tell ‘zero titles’ from ‘could not parse titles.’ That is a classic reliability trade-off in scraper-style clients.

Domain changes are only the visible part of the break

The May issue highlighted a new URL, but the later repair work went beyond replacing a domain string. It addressed Next.js data extraction, chapter parsing, image proxying, and filters. That tells us the redesign changed behavior at several layers. A simple base-URL patch would not have been enough.

Risks and Trade-Offs for Third-Party Source Extensions

A source extension can feel like a normal app feature, but operationally it is an integration maintained by people who do not control the target website. That creates three recurring risks: schema drift, anti-bot friction, and distribution lag. Any one of them can make a working source fail overnight.

Schema drift is the risk visible here. A website can rename fields, wrap responses differently, move from HTML to API calls, or change framework internals. Anti-bot friction is separate: Mihon’s own documentation notes that some sources use Cloudflare protections that can loop in WebView or intentionally deter app clients. Distribution lag is the delay between a maintainer fix and a user actually installing the updated extension.

The practical trade-off is control versus reliability. Third-party extensions give readers flexible access and migration tools, but they inherit upstream volatility. our YouTube Vanced and ReVanced settings guide shows a comparable pattern in another unofficial Android ecosystem, where users gain customization but accept a maintenance relationship with changing upstream services.

There is also a trust boundary around APK distribution. Users should not solve a source error by downloading an unknown ‘fixed’ extension from a random mirror. The official repository and extension index are better evidence because they preserve version history and issue context.

The Future of Diva Scans in 2027

The 2027 outlook depends less on reader demand than on whether the website and extension can maintain a stable integration contract. The current source already moved toward direct API endpoints and defensive parsing, which is a more resilient base than relying on one HTML layout. If those endpoints remain stable, future visual redesigns may cause fewer breakages.

The uncertainty is that there is no public compatibility guarantee between the site and the third-party extension. The May 2026 redesign changed the domain and page behavior, and the current implementation still contains framework-specific and media-host workarounds. That means another major backend or CDN change could require another extension update.

A second trend is richer content state. The live site shows locked, coin-priced, and unlocked chapters, while the extension exposes a preference for paid chapter visibility. More state means more parser branches and more edge cases. Stable APIs and explicit status fields would reduce that ambiguity, but we found no public 2027 roadmap promising such a contract.

The realistic forecast is therefore conditional. If maintainers keep the extension current and the site keeps predictable API responses, the experience should become less fragile. If domain, framework, or anti-bot changes continue without notice, occasional breakage will remain part of using the source through a third-party client.

Takeaways

The June JSON error was part of a broader website redesign and data-contract break, not strong evidence of an Android 13-specific bug.
Issue #16693 duplicated an earlier problem trail that began with a May 31 domain and design change report.
Current source code is more defensive because it handles multiple JSON response shapes and normalizes image URLs.
The verified extension index now shows version 1.4.25, so users on 1.4.21 or 1.4.23 should not troubleshoot as if those builds were current.
WebView, cookies, Android System WebView, and crash logs are the right next checks after updating app and extension versions.
A third-party source can break again whenever the upstream website changes private APIs, framework data, anti-bot rules, or media hosts.

Conclusion

This failure is a useful example of why third-party source errors should be diagnosed from the integration boundary outward. The strongest evidence is chronological: a May redesign and domain-change report, a June repair proposal focused on parsing and images, repeated JsonDecodingException tickets, and a later extension version with more defensive code.

For readers, the right response is measured. Update Mihon and the extension, test the site in WebView, clear stale browser state, keep the system WebView current, and capture logs if the error persists. Do not assume a reinstall will fix a server-side contract change, and do not replace a trusted extension with a random mirror build.

For maintainers, the current code shows the right direction: reduce dependence on one page shape, fail gracefully, and make upstream changes observable. The remaining limitation is structural. A third-party client can become more resilient, but it cannot make an unofficial website contract permanent.

Frequently Asked Questions

Why is Diva scans showing a JSON decoding exception in Mihon?

The June 2026 reports point to a website and data-structure change that no longer matched the extension’s parser. Earlier issue #16352 documented a redesigned site and new domain, while later tickets repeated the JsonDecodingException. Update both Mihon and the extension before assuming the error is still the same unresolved defect.

Was GitHub issue #16693 the original bug report?

No. GitHub marked #16693 as a duplicate. Issue #16352 had already been opened on May 31, 2026, describing a redesigned website and new domain. Issue #16586 then reported a JsonDecodingException on June 9, several days before #16693 was opened.

What extension version is current?

The live Keiyoushi extension index showed version 1.4.25 when checked on August 24, 2026. Earlier issue reports referenced 1.4.21 and 1.4.23, so users troubleshooting those builds should update before comparing their symptoms with current source behavior.

Should I clear Mihon cache when a source stops working?

Clearing general cache is not the first step. Mihon’s official guidance is more specific: use WebView, clear cookies and WebView data, and keep Android System WebView or Chrome current. Those steps target the browser state and verification layer that many sources rely on.

Can a website redesign break a Mihon extension even if the site still opens?

Yes. A browser can render a redesigned site while an extension still expects old HTML paths, embedded Next.js data, JSON fields, or image URLs. That is why a source can look normal in a browser but fail inside the app until its integration code is updated.

Is reinstalling the extension the best fix?

Not usually. First verify that you have the latest extension from the official index. Reinstalling the same outdated package does not repair a changed API contract. If installation itself fails, check package signatures and use trusted distribution paths rather than unofficial mirrors.

What if the source still fails after updating?

Open the source in WebView, complete any verification, clear WebView cookies and data, update the system WebView, then capture crash logs. If the source remains unusable, migration can preserve library continuity while maintainers investigate. For comparable unofficial Android maintenance patterns, see our YouTube Vanced and ReVanced settings guide.

Methodology

Our desk reviewed the supplied editorial brief, the live GitHub issues #16352, #16586, and #16693, pull request #16478, the current DivaScans.kt source file, the Keiyoushi extension index, Mihon’s official troubleshooting guide and latest release page, and the live DivaScans domain behavior. Internal links were verified against published pages on Perplexity AI Magazine before insertion.

We prioritized repository and project documentation over third-party summaries. Dates, version numbers, issue labels, and code behavior were checked against live pages on August 24, 2026. We did not install or execute the extension on an Android device, so current end-to-end functionality, individual title availability, login state, and paid chapter behavior were not independently tested.

The analysis considers the counterargument that an app or device bug could also cause a JSON exception. In this case, repeated source-specific reports, the documented website redesign, and source-code changes aimed at response parsing provide stronger evidence for an upstream integration break. A device-specific defect cannot be ruled out for every user without logs.

This article was drafted with AI assistance and reviewed by the Perplexity AI Editorial Team. All data, citations, and claims have been independently verified against primary sources.