For someone experimenting with technical SEO - sometimes intrusive thoughts take over. One random dive into the JSON-LD spec, and suddenly you're wondering if you can hack search engines into discovering your backlinks faster. That's exactly what kicked off an X thread in late December 2025: a wild idea to use the @reverse property in schema.org markup to self-declare incoming links as "reverse mentions."
The gist? Normally, structured data lets your page say "I mention this other thing." Flip it with @reverse, and your page declares "This other thing mentions me" - pointing to external pages that link back to you. It validates cleanly in tools like Google's Rich Results Test, but the big question: Will bots like Googlebot treat these as crawl hints or trust signals, speeding up backlink indexing and credit? Or is it just elegant bloat that'll get ignored (or worse, flagged)?
As a longtime Joomla developer behind RicheyWeb, I floated this as pure experimentation - no one's documented trying it for backlinks before. In a landscape where tools like Ahrefs often spot new links weeks ahead of Google Search Console, proactive self-reporting via schema could be a sneaky edge. Let's break it down, speculate wildly, and explore how to test it yourself.
JSON-LD and @reverse Primer: Flipping the Script on Relationships
JSON-LD (JavaScript Object Notation for Linked Data) is the go-to format for embedding schema.org structured data - clean script tags in your HTML that help search engines parse entities and relationships without messing up your visible content. Google pushes it hard for rich results and entity understanding, especially as AI-driven search leans on knowledge graphs.
The "mentions" property (on types like CreativeWork or WebPage) typically points outward: your page references another entity. But schema.org doesn't define a direct inverse like "mentionedBy." Enter @reverse from the JSON-LD 1.1 specification: it inverts relationships on the fly, letting you express inbound links from your side.
Here's a bit of a primer on mentions entities.
In my tweet, I provide a less detailed object than this example snippet, which would be nested in a standard Article schema:
JSON
{
"@context": "https://schema.org",
"@type": "WebPage",
// ... other properties ...
"@reverse": {
"mentions": [
{
"@type": "WebPage",
"url": "https://example.com/page-that-links-to-me"
},
// Add more backlink URLs here
]
}
}Syntactically perfect - no validation errors. The novelty? Applying this to real external backlinks, turning your schema into a self-reported link map.
The SEO Speculation: Could This Accelerate Backlink Credit?
Here's where the intrusive thoughts pay off: Backlink discovery isn't instant. Googlebot crawls the web, follows links, and attributes equity over time. If you're monitoring with paid tools, you often know about new links first. What if embedding them as reverse mentions gives bots a nudge - "Hey, check these pages for links to me"?
Potential upsides:
- Faster indexing/verification: Schema hints could prioritize crawling those URLs, closing the gap between your tracking and Google's reports.
- Stronger entity signals: In an era of Search Generative Experience (SGE) and AI overviews, structured data feeds knowledge graphs. Proactive inbound declarations might reinforce your site's authority or topical relevance.
- Low-risk edge: Unlike spammy tactics, this uses official spec features on real links.
- 100% Valid schema: There are some wacky inventions out there being pushed as GEO or AEO solutions that are complete fantasy - this isn't one of them. You'll find the technical references linked here in the page.
But realism check: Search engines have always discovered links via crawling, not self-declaration. No public tests show @reverse influencing backlinks - searches through SEO forums, GitHub issues, and schema discussions turn up zilch on this specific hack. Closest analogs are internal entity flips (e.g., alumniOf inverses) or citation tracking, not external link gaming. Overdo it with hundreds of reverses, and it risks schema bloat or manipulation flags.
Still... what if? In a post-Helpful Content Update world, genuine signals matter. This could be untapped, especially if combined with dynamic generation.
RicheyWeb's Commitment to Advanced Schema Automation in Joomla
This experiment doesn't come from thin air - it's rooted in RicheyWeb's deep dive into schema.org for Joomla. Core Joomla 5+ offers basic structured data via system plugins (e.g., breadcrumbs, articles, organizations), but I've critiqued them as incomplete or flawed, lagging behind modern SEO needs.
I'm fully committed to advanced, automated implementations: dynamic, layered entity graphs with no arbitrary limits. Think comprehensive WebPage setups intertwined with Organization, FAQPage, ItemList, SearchAction, and more - all generated on-the-fly for maximum entity recognition and crawl efficiency. Testbed sites, RicheyWeb and greatnaturalcures.com, showcase this "schema-maxxing" in action, pushing boundaries to see how far structured data can boost visibility.
To demonstrate transparency, pages exploring these techniques - like this one - I have a simple JavaScript link below. Click it to toggle a pretty-printed view of the full JSON-LD schema generated for the current page:
View JSON-LD markup for the current page.
No smoke and mirrors - just clean, automated markup you can inspect yourself, potentially including experimental @reverse entries. There aren't any @reverse entries on this page, because that would require I know about some - which I don't because this article is new. I have included this button on the System - AdminExile page, which has a ton of backlinks and is configured to process @reverse mentions. Look for a green JSON-LD button near the bottom of the page.
Implementation and Testing: Roll Your Own Experiment
Ready to try? Start small:
- Identify real backlinks (via Ahrefs, Semrush, or GSC).
- Add the @reverse block to your main schema (e.g., on high-value pages).
- Validate with Google's Rich Results Test.
- For Joomla users: Sadly - the Joomla core is not capable of this kind of data injection. The RicheyWeb extensions that enable this are highly experimental - and will probably never be released on any sites other than those hosted by RicheyWeb because the negative potential is too great.
Pitfalls, Ethics, and Future Possibilities
Caveats abound: This exposes your backlink intel (privacy hit), adds markup weight, and might do absolutely nothing if bots ignore self-reports. Ethics matter - only declare genuine links; faking them screams manipulation.
Future vibes? As AI search devours structured data for context, bidirectional entity links could gain weight. Proactive graphs might shine in entity-oriented ranking.
Bottom line: Crazy or genius? My experiment is uncharted - test it, share results on X or forums, and let's crowdsource if @reverse moves the needle. It seems worth watching.
The @reverse property in JSON-LD allows you to express inverse relationships without needing a dedicated inverse property in the vocabulary. It flips the direction of a property, enabling bidirectional linking in structured data graphs.
Regular properties point outward from your entity, such as using "mentions" to reference external pages. @reverse inverts this, allowing your page to declare relationships coming inbound, like pages that reference or link to you.
Yes, syntactically it works by nesting @reverse with a property like "mentions" to list external WebPage URLs that link back to your page. This creates "reverse mentions" in the data graph.
This is untested and speculative. No public evidence shows search engines treating self-declared reverse mentions as backlink signals or crawl hints. Backlinks are typically discovered through crawling, not self-reporting.
No references exist to this specific use case. Searches across forums, specs, and discussions show @reverse primarily for internal entity relationships, not external backlink signaling.
Potentially, if search engines parse it as a hint to prioritize crawling listed URLs. However, it risks being ignored or viewed as manipulative if overused, with no confirmed impact on rankings.
Risks include schema bloat, exposure of backlink tracking intel, or potential spam flags if declarations are inaccurate. Always use only genuine backlinks.
Joomla core offers basic schema, but developers like Michael Richey build custom automated systems for layered markup, enabling experiments like dynamic @reverse injection.
No direct inverse exists for "mentions." @reverse in JSON-LD provides a workaround for properties without defined inverses.
Start small on test pages, validate thoroughly, and monitor Search Console for changes in link reports or crawl stats. Community testing is needed since this is novel.
Frequently Asked Questions:
What is the @reverse property in JSON-LD?
How does @reverse differ from regular properties in schema.org markup?
Can @reverse be used to declare incoming backlinks in schema markup?
Will search engines like Google use @reverse declarations for faster backlink discovery?
Is anyone else using @reverse for backlink-related experiments in SEO?
Could self-reporting backlinks via @reverse speed up link equity or indexing?
What risks come with experimenting with @reverse for reverse mentions?
How is @reverse implemented in Joomla for advanced schema automation?
Does schema.org have inverse properties for "mentions" like mentionedBy?
Should I test @reverse reverse mentions on my site?
