diff --git a/src/main/java/com/knowledgepixels/nanodash/page/MaintainedResourcePage.java b/src/main/java/com/knowledgepixels/nanodash/page/MaintainedResourcePage.java
index 6926ddcb..46f46f18 100644
--- a/src/main/java/com/knowledgepixels/nanodash/page/MaintainedResourcePage.java
+++ b/src/main/java/com/knowledgepixels/nanodash/page/MaintainedResourcePage.java
@@ -23,6 +23,7 @@
 import org.apache.wicket.request.mapper.parameter.PageParameters;
 import org.eclipse.rdf4j.model.IRI;
 import org.eclipse.rdf4j.model.util.Values;
+import org.nanopub.Nanopub;
 
 import java.util.List;
 import java.util.Optional;
@@ -73,6 +74,7 @@ public MaintainedResourcePage(final PageParameters parameters) {
 
         MaintainedResource resource = MaintainedResourceRepository.get().findById(parameters.get("id").toString());
         resourceId = resource.getId();
+        redirectIfRdfRequested(new RdfSource("resource", resourceId, null, List.of()));
         resourceModel = new LoadableDetachableModel<MaintainedResource>() {
             @Override
             protected MaintainedResource load() {
@@ -207,6 +209,18 @@ protected boolean hasAutoRefreshEnabled() {
         return true;
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The resource's declaring nanopublication describes it.
+     */
+    @Override
+    protected RdfSource getRdfSource() {
+        MaintainedResource resource = resourceModel.getObject();
+        List<Nanopub> declarations = resource != null && resource.getNanopub() != null ? List.of(resource.getNanopub()) : List.of();
+        return new RdfSource("resource", resourceId, null, declarations);
+    }
+
     /**
      * {@inheritDoc}
      */
diff --git a/src/main/java/com/knowledgepixels/nanodash/page/NanodashPage.java b/src/main/java/com/knowledgepixels/nanodash/page/NanodashPage.java
index d7cfa691..5b337c2e 100644
--- a/src/main/java/com/knowledgepixels/nanodash/page/NanodashPage.java
+++ b/src/main/java/com/knowledgepixels/nanodash/page/NanodashPage.java
@@ -20,11 +20,13 @@
 import org.apache.wicket.markup.head.JavaScriptHeaderItem;
 import org.apache.wicket.markup.head.JavaScriptReferenceHeaderItem;
 import org.apache.wicket.markup.head.MetaDataHeaderItem;
+import org.apache.wicket.markup.head.StringHeaderItem;
 import org.apache.wicket.markup.html.WebPage;
 import org.apache.wicket.protocol.http.WebApplication;
 import org.apache.wicket.request.cycle.RequestCycle;
 import org.apache.wicket.request.flow.RedirectToUrlException;
 import org.apache.wicket.request.http.WebRequest;
+import org.apache.wicket.request.http.WebResponse;
 import org.apache.wicket.request.mapper.parameter.PageParameters;
 import org.apache.wicket.request.resource.JavaScriptResourceReference;
 import org.slf4j.Logger;
@@ -360,6 +362,64 @@ protected String getMetaTitle() {
         return title == null ? SITE_NAME : title.toString();
     }
 
+    /**
+     * What this page offers as RDF (issue #710). Pages about a resource that the download
+     * page can serve override this; the default is nothing, which leaves the page HTML-only.
+     *
+     * @return the RDF source, or null for a page without one
+     */
+    protected RdfSource getRdfSource() {
+        return null;
+    }
+
+    /**
+     * Answers a client that asked for RDF in its {@code Accept} header with a 303 to the
+     * download page in the matching format, and lets everyone else have the HTML (issue
+     * #710). Pages call this from their constructor as soon as they know their resource,
+     * before building anything, so that a machine client gets its redirect without the
+     * page's own work being done first. Either way the response is marked as varying on
+     * the {@code Accept} header, so that caches keep the two apart.
+     *
+     * @param source what to serve; its declarations are not needed here and may be empty
+     * @throws RedirectToUrlException when the client asked for RDF
+     */
+    protected void redirectIfRdfRequested(RdfSource source) {
+        if (getResponse() instanceof WebResponse webResponse) {
+            webResponse.setHeader("Vary", "Accept");
+        }
+        String accept = getRequest() instanceof WebRequest webRequest ? webRequest.getHeader("Accept") : null;
+        RdfNegotiation.Variant variant = RdfNegotiation.negotiate(accept);
+        if (variant == null) return;
+        String url = source.downloadUrl(variant);
+        logger.info("RDF requested as {} for {} {}; redirecting to {}", variant.mediaType(), source.type(), source.id(), url);
+        throw new RedirectToUrlException(url, 303);
+    }
+
+    /**
+     * Renders what lets HTML-reading tools find this page's RDF (issue #710): one
+     * alternate link per download format, and the declaring assertions as an embedded
+     * JSON-LD block. Nothing is rendered for a page without an RDF source.
+     *
+     * @param response the header response to render into
+     */
+    private void renderRdfLinks(IHeaderResponse response) {
+        RdfSource source = getRdfSource();
+        if (source == null) return;
+        for (RdfNegotiation.Variant variant : RdfNegotiation.VARIANTS) {
+            response.render(MetaDataHeaderItem.forLinkTag("alternate", source.downloadUrl(variant))
+                    .addTagAttribute("type", variant.mediaType()));
+        }
+        String jsonLd;
+        try {
+            jsonLd = source.toEmbeddedJsonLd(source.downloadUrl(RdfNegotiation.VARIANTS.get(0)));
+        } catch (Exception ex) {
+            logger.warn("Could not embed the JSON-LD for {} {}: {}", source.type(), source.id(), ex.getMessage());
+            return;
+        }
+        if (jsonLd == null) return;
+        response.render(StringHeaderItem.forString("<script type=\"application/ld+json\">\n" + jsonLd + "\n</script>\n"));
+    }
+
     /**
      * Renders the description, canonical URL, Open Graph and Twitter card tags that
      * search engines and link previews read (issue #704).
@@ -409,6 +469,7 @@ private static MetaDataHeaderItem propertyMetaTag(String property, String conten
     public void renderHead(IHeaderResponse response) {
         super.renderHead(response);
         renderPageMetadata(response);
+        renderRdfLinks(response);
         response.render(CssHeaderItem.forUrl(getStyleSheetUrl()));
         response.render(JavaScriptHeaderItem.forReference(getApplication().getJavaScriptLibrarySettings().getJQueryReference()));
         response.render(JavaScriptReferenceHeaderItem.forReference(nanodashJs));
diff --git a/src/main/java/com/knowledgepixels/nanodash/page/RdfNegotiation.java b/src/main/java/com/knowledgepixels/nanodash/page/RdfNegotiation.java
new file mode 100644
index 00000000..c59199f6
--- /dev/null
+++ b/src/main/java/com/knowledgepixels/nanodash/page/RdfNegotiation.java
@@ -0,0 +1,82 @@
+package com.knowledgepixels.nanodash.page;
+
+import com.knowledgepixels.nanodash.Utils;
+import org.commonjava.mimeparse.MIMEParse;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Decides, from an HTTP {@code Accept} header, whether a resource page should answer with
+ * RDF instead of HTML, and in which of the download page's formats (issue #710).
+ * <p>
+ * Graph-aware formats carry the complete nanopublications, as the download tab's top
+ * section does. Triple-only formats cannot hold named graphs, so they carry the merged
+ * assertions instead.
+ */
+public final class RdfNegotiation {
+
+    /**
+     * One RDF representation the download page can serve.
+     *
+     * @param mediaType      the media type a client asks for, and the download page answers with
+     * @param format         the download page's {@code format} parameter
+     * @param assertionsOnly whether the download page's {@code assertions} switch is set
+     */
+    public record Variant(String mediaType, String format, boolean assertionsOnly) {
+    }
+
+    /**
+     * The representations offered, in the order a link list should show them.
+     */
+    public static final List<Variant> VARIANTS = List.of(
+            new Variant(Utils.TYPE_TRIG, "trig", false),
+            new Variant(Utils.TYPE_NQUADS, "nq", false),
+            new Variant(Utils.TYPE_JSONLD, "jsonld", false),
+            new Variant(Utils.TYPE_TRIX, "trix", false),
+            new Variant("text/turtle", "turtle", true),
+            new Variant("application/n-triples", "nt", true),
+            new Variant("application/rdf+xml", "rdfxml", true)
+    );
+
+    /**
+     * The types offered to the media-type matcher. HTML comes last on purpose: the matcher
+     * breaks ties in favour of the last entry, so a wildcard such as {@code *}{@code /}{@code *}
+     * from a command-line client or a browser resolves to the page, not to RDF.
+     */
+    private static final List<String> OFFERED_TYPES;
+
+    static {
+        List<String> types = new ArrayList<>();
+        for (Variant v : VARIANTS) types.add(v.mediaType());
+        types.add(Utils.TYPE_HTML);
+        OFFERED_TYPES = List.copyOf(types);
+    }
+
+    private RdfNegotiation() {
+    }
+
+    /**
+     * Picks the RDF representation a client asked for.
+     *
+     * @param acceptHeader the request's {@code Accept} header; may be null or blank
+     * @return the variant to serve, or null when the client gets HTML, which it does when
+     * it asks for it, when it accepts anything, when it names no type this page offers, or
+     * when the header cannot be parsed
+     */
+    public static Variant negotiate(String acceptHeader) {
+        if (acceptHeader == null || acceptHeader.isBlank()) return null;
+        String best;
+        try {
+            best = MIMEParse.bestMatch(OFFERED_TYPES, acceptHeader);
+        } catch (Exception ex) {
+            return null;
+        }
+        if (best == null || best.isEmpty() || best.equals(Utils.TYPE_HTML)) return null;
+        for (Variant v : VARIANTS) {
+            if (v.mediaType().equals(best)) return v;
+        }
+        return null;
+    }
+
+}
diff --git a/src/main/java/com/knowledgepixels/nanodash/page/RdfSource.java b/src/main/java/com/knowledgepixels/nanodash/page/RdfSource.java
new file mode 100644
index 00000000..40066611
--- /dev/null
+++ b/src/main/java/com/knowledgepixels/nanodash/page/RdfSource.java
@@ -0,0 +1,108 @@
+package com.knowledgepixels.nanodash.page;
+
+import com.knowledgepixels.nanodash.Utils;
+import org.apache.wicket.request.mapper.parameter.PageParameters;
+import org.eclipse.rdf4j.model.Model;
+import org.eclipse.rdf4j.model.Statement;
+import org.eclipse.rdf4j.model.impl.LinkedHashModel;
+import org.eclipse.rdf4j.model.vocabulary.VOID;
+import org.eclipse.rdf4j.rio.RDFFormat;
+import org.eclipse.rdf4j.rio.RDFWriter;
+import org.eclipse.rdf4j.rio.Rio;
+import org.eclipse.rdf4j.rio.helpers.BasicWriterSettings;
+import org.eclipse.rdf4j.rio.jsonld.JSONLDMode;
+import org.eclipse.rdf4j.rio.jsonld.JSONLDSettings;
+import org.nanopub.Nanopub;
+import org.nanopub.NanopubWithNs;
+
+import java.io.StringWriter;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * What a resource page has to offer as RDF (issue #710): the download page's view of the
+ * resource, plus the nanopublications that declare the resource itself, whose assertions
+ * are small enough to embed in the page.
+ *
+ * @param type         the download page's {@code type}: user, space, resource or part
+ * @param id           the resource IRI
+ * @param contextId    the containing resource for a part, null otherwise
+ * @param declarations the nanopublications declaring the resource; empty when unknown
+ */
+public record RdfSource(String type, String id, String contextId, List<Nanopub> declarations) {
+
+    /**
+     * Prefixes a nanopublication declares for its own URI space, which mean nothing outside it.
+     */
+    private static final List<String> NANOPUB_LOCAL_PREFIXES = List.of("this", "sub");
+
+    /**
+     * The download page parameters for one representation of this source.
+     *
+     * @param variant the representation
+     * @return the parameters
+     */
+    public PageParameters downloadParameters(RdfNegotiation.Variant variant) {
+        PageParameters params = new PageParameters()
+                .set("type", type)
+                .set("id", id);
+        if (contextId != null) params.set("context", contextId);
+        params.set("format", variant.format());
+        if (variant.assertionsOnly()) params.set("assertions", "");
+        return params;
+    }
+
+    /**
+     * The absolute download URL for one representation of this source, on the configured
+     * website address and without any session id.
+     *
+     * @param variant the representation
+     * @return the URL
+     */
+    public String downloadUrl(RdfNegotiation.Variant variant) {
+        return Utils.absolutePageUrl(DownloadRdfPage.class, downloadParameters(variant));
+    }
+
+    /**
+     * The declaring assertions as a JSON-LD document for a {@code <script>} block in the
+     * page head, so that HTML-reading tools and search engines find the resource's own
+     * triples. A {@code void:dataDump} triple points them at the complete download.
+     * <p>
+     * The document keeps the nanopublications' own prefixes as its context, identifies
+     * the resource by its IRI rather than by the page's URL, and has every {@code <}
+     * escaped, so that a text value cannot close the script block it sits in.
+     *
+     * @param dumpUrl the URL of the complete TriG download
+     * @return the JSON-LD document, or null when there is nothing to declare
+     */
+    public String toEmbeddedJsonLd(String dumpUrl) {
+        if (declarations.isEmpty()) return null;
+        Model model = new LinkedHashModel();
+        Map<String, String> namespaces = new LinkedHashMap<>();
+        for (Nanopub np : declarations) {
+            if (np instanceof NanopubWithNs withNs) {
+                withNs.getNs().forEach((prefix, ns) -> {
+                    if (!NANOPUB_LOCAL_PREFIXES.contains(prefix)) namespaces.put(prefix, ns);
+                });
+            }
+            for (Statement st : np.getAssertion()) {
+                model.add(st.getSubject(), st.getPredicate(), st.getObject());
+            }
+        }
+        if (model.isEmpty()) return null;
+        namespaces.putIfAbsent("void", VOID.NAMESPACE);
+        model.add(Utils.vf.createIRI(id), VOID.DATA_DUMP, Utils.vf.createIRI(dumpUrl));
+
+        StringWriter out = new StringWriter();
+        RDFWriter writer = Rio.createWriter(RDFFormat.JSONLD, out);
+        writer.getWriterConfig().set(JSONLDSettings.JSONLD_MODE, JSONLDMode.COMPACT);
+        writer.getWriterConfig().set(BasicWriterSettings.PRETTY_PRINT, true);
+        writer.startRDF();
+        namespaces.forEach(writer::handleNamespace);
+        model.forEach(writer::handleStatement);
+        writer.endRDF();
+        return out.toString().replace("<", "\\u003c");
+    }
+
+}
diff --git a/src/main/java/com/knowledgepixels/nanodash/page/ResourcePartPage.java b/src/main/java/com/knowledgepixels/nanodash/page/ResourcePartPage.java
index 898bb699..ce77eb61 100644
--- a/src/main/java/com/knowledgepixels/nanodash/page/ResourcePartPage.java
+++ b/src/main/java/com/knowledgepixels/nanodash/page/ResourcePartPage.java
@@ -73,11 +73,29 @@ public String getPartLabel() {
         return partLabel;
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The nanopublication defining the part declares it; a part without one has nothing
+     * to embed, but its download still lists what the views show about it.
+     */
+    @Override
+    protected RdfSource getRdfSource() {
+        Nanopub definition = Utils.getAsNanopub(definitionNanopubId);
+        List<Nanopub> declarations = definition == null ? List.of() : List.of(definition);
+        return new RdfSource("part", getPartId(), getPageParameters().get("context").toString(), declarations);
+    }
+
     /**
      * Resource with profile (Space or MaintainedResource) object with the data shown on this page.
      */
     private AbstractResourceWithProfile resourceWithProfile;
 
+    /**
+     * The nanopublication defining this part, or null when none is known.
+     */
+    private String definitionNanopubId;
+
     /**
      * The part's label as resolved for the title, handed to links out of this page so
      * their back-link can name the part.
@@ -130,6 +148,7 @@ public ResourcePartPage(final PageParameters parameters) {
                 throw new IllegalArgumentException("Not a resource, space, or user: " + contextId);
             }
         }
+        redirectIfRdfRequested(new RdfSource("part", id, contextId, List.of()));
 
         QueryRef getDefQuery = ViewDataFetcher.partDefinitionQueryRef(id, contextId, resourceWithProfile);
         ApiResponse getDefResp = ApiCache.retrieveResponseSync(getDefQuery, false);
@@ -161,6 +180,7 @@ public ResourcePartPage(final PageParameters parameters) {
         } else {
             nanopubId = null;
         }
+        definitionNanopubId = nanopubId;
 //        if (getDefResp == null || getDefResp.getData().isEmpty()) {
 //            throw new RestartResponseException(ExplorePage.class, parameters);
 //        }
diff --git a/src/main/java/com/knowledgepixels/nanodash/page/SpacePage.java b/src/main/java/com/knowledgepixels/nanodash/page/SpacePage.java
index 615f12e5..cc0fe9a3 100644
--- a/src/main/java/com/knowledgepixels/nanodash/page/SpacePage.java
+++ b/src/main/java/com/knowledgepixels/nanodash/page/SpacePage.java
@@ -24,6 +24,7 @@
 import org.apache.wicket.model.Model;
 import org.apache.wicket.request.mapper.parameter.PageParameters;
 import org.eclipse.rdf4j.model.IRI;
+import org.nanopub.Nanopub;
 
 import java.util.List;
 import java.util.Optional;
@@ -79,6 +80,7 @@ public SpacePage(final PageParameters parameters) {
 
         Space space = resolveSpace(parameters);
         spaceId = space.getId();
+        redirectIfRdfRequested(new RdfSource("space", spaceId, null, List.of()));
         spaceModel = new LoadableDetachableModel<Space>() {
             @Override
             protected Space load() {
@@ -304,6 +306,18 @@ private static String spaceMetaDescription(Space space) {
         return "The " + space.getLabel() + " space on Nanodash, with its nanopublications, members and views.";
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * The space's root nanopublication declares it.
+     */
+    @Override
+    protected RdfSource getRdfSource() {
+        Space space = spaceModel.getObject();
+        List<Nanopub> declarations = space != null && space.getNanopub() != null ? List.of(space.getNanopub()) : List.of();
+        return new RdfSource("space", spaceId, null, declarations);
+    }
+
     /**
      * Resolves the {@link Space} from the repository, or redirects as needed.
      *
diff --git a/src/main/java/com/knowledgepixels/nanodash/page/UserPage.java b/src/main/java/com/knowledgepixels/nanodash/page/UserPage.java
index 77add0ee..57f7f5a4 100644
--- a/src/main/java/com/knowledgepixels/nanodash/page/UserPage.java
+++ b/src/main/java/com/knowledgepixels/nanodash/page/UserPage.java
@@ -22,9 +22,12 @@
 import org.apache.wicket.request.mapper.parameter.PageParameters;
 import org.apache.wicket.request.resource.ContextRelativeResourceReference;
 import org.eclipse.rdf4j.model.IRI;
+import org.nanopub.Nanopub;
+import org.nanopub.extra.setting.IntroNanopub;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
@@ -73,6 +76,7 @@ public UserPage(final PageParameters parameters) {
         if (parameters.get("id") == null) throw new RedirectToUrlException(ProfilePage.MOUNT_PATH);
         final String userIriString = parameters.get("id").toString();
         userIri = Utils.vf.createIRI(userIriString);
+        redirectIfRdfRequested(new RdfSource("user", userIriString, null, List.of()));
 
         for (String pk : User.getPubkeyhashes(userIri, null)) {
             pubkeyHashes += " " + pk;
@@ -238,6 +242,20 @@ protected void onContentLoaded(Component content, Optional<AjaxRequestTarget> ta
         }
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * A user is declared by their approved introduction nanopublications.
+     */
+    @Override
+    protected RdfSource getRdfSource() {
+        List<Nanopub> declarations = new ArrayList<>();
+        for (IntroNanopub intro : User.getIntroNanopubs(userIri)) {
+            if (User.isApproved(intro) && intro.getNanopub() != null) declarations.add(intro.getNanopub());
+        }
+        return new RdfSource("user", userIri.stringValue(), null, declarations);
+    }
+
     /**
      * <p>hasAutoRefreshEnabled.</p>
      *
diff --git a/src/test/java/com/knowledgepixels/nanodash/page/NanodashPageRdfTest.java b/src/test/java/com/knowledgepixels/nanodash/page/NanodashPageRdfTest.java
new file mode 100644
index 00000000..be8ac1ff
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/page/NanodashPageRdfTest.java
@@ -0,0 +1,125 @@
+package com.knowledgepixels.nanodash.page;
+
+import com.knowledgepixels.nanodash.WicketApplication;
+import org.apache.wicket.util.tester.WicketTester;
+import org.eclipse.rdf4j.rio.RDFFormat;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.nanopub.NanopubImpl;
+
+import java.io.File;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests how a page about a resource serves that resource's RDF (issue #710): by content
+ * negotiation for clients that ask for it, and by links and an embedded block for the rest.
+ */
+class NanodashPageRdfTest {
+
+    private WicketTester tester;
+
+    @BeforeEach
+    void setUp() throws Exception {
+        tester = new WicketTester(new WicketApplication());
+        tester.setFollowRedirects(false);
+        RdfSourceTestPage.declaration = new NanopubImpl(new File("src/test/resources/np-space-declaration.trig"), RDFFormat.TRIG);
+    }
+
+    private void start(String accept) {
+        if (accept != null) tester.getRequest().setHeader("Accept", accept);
+        tester.startPage(RdfSourceTestPage.class);
+    }
+
+    /**
+     * A client asking for Turtle is sent to the assertions-only Turtle download, with a
+     * 303 rather than a 302, as the download is another resource than the page.
+     */
+    @Test
+    void redirectsTurtleRequestsToTheAssertionsDownload() {
+        start("text/turtle");
+        assertEquals(303, tester.getLastResponse().getStatus());
+        String location = tester.getLastResponse().getHeader("Location");
+        assertNotNull(location);
+        assertTrue(location.startsWith("http"), location);
+        assertTrue(location.contains("/download-rdf?"), location);
+        assertTrue(location.contains("type=space"), location);
+        assertTrue(location.contains("format=turtle"), location);
+        assertTrue(location.contains("assertions"), location);
+        assertFalse(location.toLowerCase().contains(";jsessionid="), location);
+    }
+
+    /**
+     * A client asking for TriG gets the complete nanopublications.
+     */
+    @Test
+    void redirectsTrigRequestsToTheFullDownload() {
+        start("application/trig");
+        assertEquals(303, tester.getLastResponse().getStatus());
+        String location = tester.getLastResponse().getHeader("Location");
+        assertTrue(location.contains("format=trig"), location);
+        assertFalse(location.contains("assertions"), location);
+    }
+
+    /**
+     * Both answers vary on the Accept header, so that a cache never hands the RDF
+     * redirect to a browser or the page to a Linked Data client.
+     */
+    @Test
+    void marksBothAnswersAsVaryingOnAccept() throws Exception {
+        start("text/turtle");
+        assertEquals("Accept", tester.getLastResponse().getHeader("Vary"));
+        setUp();
+        start("text/html");
+        assertEquals(200, tester.getLastResponse().getStatus());
+        assertEquals("Accept", tester.getLastResponse().getHeader("Vary"));
+    }
+
+    /**
+     * A browser gets the page, which links every RDF representation for tools that
+     * read HTML.
+     */
+    @Test
+    void rendersAlternateLinksForEveryFormat() {
+        start("text/html,*/*;q=0.8");
+        assertEquals(200, tester.getLastResponse().getStatus());
+        String document = tester.getLastResponse().getDocument();
+        assertTrue(document.contains("<link rel=\"alternate\" href=\"http"), document);
+        assertTrue(document.contains("type=\"application/trig\""), document);
+        assertTrue(document.contains("type=\"text/turtle\""), document);
+        assertTrue(document.contains("type=\"application/ld+json\""), document);
+        assertTrue(document.contains("type=\"application/n-quads\""), document);
+    }
+
+    /**
+     * The page embeds the resource's declaring assertion as JSON-LD, about the resource
+     * IRI and not the page URL, with a pointer to the complete download.
+     */
+    @Test
+    void embedsTheDeclarationAsJsonLd() {
+        start(null);
+        String document = tester.getLastResponse().getDocument();
+        assertTrue(document.contains("<script type=\"application/ld+json\">"), document);
+        assertTrue(document.contains(RdfSourceTestPage.RESOURCE_IRI), document);
+        assertTrue(document.contains("dataDump"), document);
+        assertTrue(document.contains("Test Workshop"), document);
+        assertTrue(document.contains("\\u003cscript>"), document);
+    }
+
+    /**
+     * Without a known declaration there is no block, but the links still lead to the
+     * download.
+     */
+    @Test
+    void leavesOutTheBlockWithoutADeclaration() {
+        RdfSourceTestPage.declaration = null;
+        start(null);
+        String document = tester.getLastResponse().getDocument();
+        assertFalse(document.contains("application/ld+json\">"), document);
+        assertTrue(document.contains("<link rel=\"alternate\""), document);
+    }
+
+}
diff --git a/src/test/java/com/knowledgepixels/nanodash/page/RdfNegotiationTest.java b/src/test/java/com/knowledgepixels/nanodash/page/RdfNegotiationTest.java
new file mode 100644
index 00000000..34cf4c33
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/page/RdfNegotiationTest.java
@@ -0,0 +1,74 @@
+package com.knowledgepixels.nanodash.page;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests which representation an {@code Accept} header selects (issue #710).
+ */
+class RdfNegotiationTest {
+
+    /**
+     * Browsers and command-line clients that accept anything get the page, not RDF.
+     */
+    @Test
+    void htmlWinsForBrowsersAndWildcards() {
+        assertNull(RdfNegotiation.negotiate(null));
+        assertNull(RdfNegotiation.negotiate(""));
+        assertNull(RdfNegotiation.negotiate("*/*"));
+        assertNull(RdfNegotiation.negotiate("text/html"));
+        assertNull(RdfNegotiation.negotiate("text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8"));
+        assertNull(RdfNegotiation.negotiate("image/png"));
+        assertNull(RdfNegotiation.negotiate("application/json"));
+    }
+
+    /**
+     * Graph-aware formats carry whole nanopublications, so they are not restricted to the
+     * assertions.
+     */
+    @Test
+    void graphFormatsCarryFullNanopubs() {
+        RdfNegotiation.Variant trig = RdfNegotiation.negotiate("application/trig");
+        assertEquals("trig", trig.format());
+        assertFalse(trig.assertionsOnly());
+        assertEquals("nq", RdfNegotiation.negotiate("application/n-quads").format());
+        assertEquals("jsonld", RdfNegotiation.negotiate("application/ld+json").format());
+        assertEquals("trix", RdfNegotiation.negotiate("application/trix").format());
+    }
+
+    /**
+     * Triple-only formats cannot hold the named graphs, so they carry the assertions.
+     */
+    @Test
+    void tripleFormatsCarryAssertionsOnly() {
+        RdfNegotiation.Variant turtle = RdfNegotiation.negotiate("text/turtle");
+        assertEquals("turtle", turtle.format());
+        assertTrue(turtle.assertionsOnly());
+        assertTrue(RdfNegotiation.negotiate("application/n-triples").assertionsOnly());
+        assertTrue(RdfNegotiation.negotiate("application/rdf+xml").assertionsOnly());
+    }
+
+    /**
+     * A Linked Data client's weighted header, with HTML allowed but not preferred, gets its
+     * preferred RDF format.
+     */
+    @Test
+    void honoursQualityWeights() {
+        assertEquals("turtle", RdfNegotiation.negotiate("text/turtle;q=0.9,application/trig;q=0.8,text/html;q=0.1").format());
+        assertEquals("trig", RdfNegotiation.negotiate("application/trig,text/html;q=0.1").format());
+        assertNull(RdfNegotiation.negotiate("text/html,text/turtle;q=0.5"));
+    }
+
+    /**
+     * A malformed header is no reason to fail the page.
+     */
+    @Test
+    void malformedHeaderGetsHtml() {
+        assertNull(RdfNegotiation.negotiate(";;;q=x"));
+    }
+
+}
diff --git a/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTest.java b/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTest.java
new file mode 100644
index 00000000..8d4f5cd3
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTest.java
@@ -0,0 +1,114 @@
+package com.knowledgepixels.nanodash.page;
+
+import org.eclipse.rdf4j.rio.RDFFormat;
+import org.junit.jupiter.api.Test;
+import org.nanopub.Nanopub;
+import org.nanopub.NanopubImpl;
+
+import java.io.File;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests the JSON-LD a resource page embeds for its declaring nanopublications (issue #710).
+ */
+class RdfSourceTest {
+
+    private static final String RESOURCE_IRI = "https://example.org/spaces/test-workshop";
+    private static final String DUMP_URL = "https://nanodash.example.org/download-rdf?type=space&id=" + RESOURCE_IRI + "&format=trig";
+
+    private static Nanopub declaration() throws Exception {
+        return new NanopubImpl(new File("src/test/resources/np-space-declaration.trig"), RDFFormat.TRIG);
+    }
+
+    private static String jsonLd() throws Exception {
+        return new RdfSource("space", RESOURCE_IRI, null, List.of(declaration())).toEmbeddedJsonLd(DUMP_URL);
+    }
+
+    /**
+     * The document is about the resource itself, by its IRI, with the assertion's triples.
+     */
+    @Test
+    void describesTheResourceByItsIri() throws Exception {
+        String doc = jsonLd();
+        assertTrue(doc.contains("\"@id\" : \"" + RESOURCE_IRI + "\"") || doc.contains("\"@id\": \"" + RESOURCE_IRI + "\""), doc);
+        assertTrue(doc.contains("Test Workshop"), doc);
+        assertTrue(doc.contains("2026-09-15T09:00:00+02:00"), doc);
+    }
+
+    /**
+     * The nanopublication's own prefixes make up the context, without the ones that only
+     * mean something inside the nanopublication.
+     */
+    @Test
+    void keepsTheDeclaredPrefixesAsContext() throws Exception {
+        String doc = jsonLd();
+        assertTrue(doc.contains("\"@context\""), doc);
+        assertTrue(doc.contains("\"gen\""), doc);
+        assertFalse(doc.contains("\"sub\""), doc);
+        assertFalse(doc.contains("\"this\""), doc);
+    }
+
+    /**
+     * A pointer to the complete download lets a link-following tool get everything the
+     * block leaves out.
+     */
+    @Test
+    void pointsAtTheFullDownload() throws Exception {
+        String doc = jsonLd();
+        assertTrue(doc.contains("dataDump"), doc);
+        assertTrue(doc.contains(DUMP_URL.replace("<", "\\u003c")), doc);
+    }
+
+    /**
+     * A text value cannot end the script block the document sits in.
+     */
+    @Test
+    void escapesAngleBracketsForTheScriptBlock() throws Exception {
+        String doc = jsonLd();
+        assertFalse(doc.contains("<"), doc);
+        assertTrue(doc.contains("\\u003cscript>"), doc);
+    }
+
+    /**
+     * Provenance and publication info stay out: the block is about the resource, not about
+     * the nanopublication.
+     */
+    @Test
+    void leavesOutTheOtherGraphs() throws Exception {
+        String doc = jsonLd();
+        assertFalse(doc.contains("wasAttributedTo"), doc);
+        assertFalse(doc.contains("introduces"), doc);
+    }
+
+    /**
+     * A resource whose declaration is not known has nothing to embed.
+     */
+    @Test
+    void nothingToEmbedWithoutDeclarations() {
+        assertNull(new RdfSource("space", RESOURCE_IRI, null, List.of()).toEmbeddedJsonLd(DUMP_URL));
+    }
+
+    /**
+     * The download parameters name the resource, its context for a part, and the variant's
+     * format and assertion switch.
+     */
+    @Test
+    void buildsTheDownloadParameters() {
+        RdfSource part = new RdfSource("part", "https://example.org/r/p1", "https://example.org/r", List.of());
+        var turtle = part.downloadParameters(RdfNegotiation.negotiate("text/turtle"));
+        assertEquals("part", turtle.get("type").toString());
+        assertEquals("https://example.org/r/p1", turtle.get("id").toString());
+        assertEquals("https://example.org/r", turtle.get("context").toString());
+        assertEquals("turtle", turtle.get("format").toString());
+        assertFalse(turtle.get("assertions").isNull());
+        var trig = part.downloadParameters(RdfNegotiation.negotiate("application/trig"));
+        assertEquals("trig", trig.get("format").toString());
+        assertTrue(trig.get("assertions").isNull());
+    }
+
+}
diff --git a/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTestPage.html b/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTestPage.html
new file mode 100644
index 00000000..5e9fb692
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTestPage.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html xmlns:wicket="http://wicket.apache.org">
+<head>
+  <wicket:head>
+    <title wicket:id="pagetitle">Test | nanodash</title>
+  </wicket:head>
+</head>
+<body>
+<wicket:extend>
+  <p>A test page about a resource.</p>
+</wicket:extend>
+</body>
+</html>
diff --git a/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTestPage.java b/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTestPage.java
new file mode 100644
index 00000000..72bfc276
--- /dev/null
+++ b/src/test/java/com/knowledgepixels/nanodash/page/RdfSourceTestPage.java
@@ -0,0 +1,41 @@
+package com.knowledgepixels.nanodash.page;
+
+import com.knowledgepixels.nanodash.component.TitleBar;
+import org.apache.wicket.markup.html.basic.Label;
+import org.apache.wicket.request.mapper.parameter.PageParameters;
+import org.nanopub.Nanopub;
+
+import java.util.List;
+
+/**
+ * A page about a fixed resource, standing in for the space, user, resource and part pages
+ * in tests of what {@link NanodashPage} does with an {@link RdfSource} (issue #710).
+ */
+public class RdfSourceTestPage extends NanodashPage {
+
+    /**
+     * The nanopublication the page's resource is declared by; set by the test before the
+     * page is started, since a page under the tester is constructed by Wicket.
+     */
+    static Nanopub declaration;
+
+    static final String RESOURCE_IRI = "https://example.org/spaces/test-workshop";
+
+    public RdfSourceTestPage(PageParameters parameters) {
+        super(parameters);
+        redirectIfRdfRequested(getRdfSource());
+        add(new TitleBar("titlebar", this));
+        add(new Label("pagetitle", "Test Workshop (space) | nanodash"));
+    }
+
+    @Override
+    public String getMountPath() {
+        return "/rdf-source-test";
+    }
+
+    @Override
+    protected RdfSource getRdfSource() {
+        return new RdfSource("space", RESOURCE_IRI, null, declaration == null ? List.of() : List.of(declaration));
+    }
+
+}
diff --git a/src/test/resources/np-space-declaration.trig b/src/test/resources/np-space-declaration.trig
new file mode 100644
index 00000000..dac19b66
--- /dev/null
+++ b/src/test/resources/np-space-declaration.trig
@@ -0,0 +1,36 @@
+@prefix this: <https://w3id.org/np/RACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC> .
+@prefix sub: <https://w3id.org/np/RACCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC/> .
+@prefix np: <http://www.nanopub.org/nschema#> .
+@prefix dct: <http://purl.org/dc/terms/> .
+@prefix npx: <http://purl.org/nanopub/x/> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix orcid: <https://orcid.org/> .
+@prefix prov: <http://www.w3.org/ns/prov#> .
+@prefix schema: <https://schema.org/> .
+@prefix gen: <https://w3id.org/kpxl/gen/terms/> .
+
+sub:Head {
+  this: a np:Nanopublication;
+    np:hasAssertion sub:assertion;
+    np:hasProvenance sub:provenance;
+    np:hasPublicationInfo sub:pubinfo .
+}
+
+sub:assertion {
+  <https://example.org/spaces/test-workshop> a gen:Space, gen:Event;
+    rdfs:label "Test Workshop";
+    dct:description "A workshop with a <script> tag in its description.";
+    <http://schema.org/startDate> "2026-09-15T09:00:00+02:00"^^xsd:dateTime;
+    gen:hasAdmin orcid:0000-0002-1267-0234 .
+}
+
+sub:provenance {
+  sub:assertion prov:wasAttributedTo orcid:0000-0002-1267-0234 .
+}
+
+sub:pubinfo {
+  this: dct:created "2026-09-14T10:00:00.000Z"^^xsd:dateTime;
+    dct:creator orcid:0000-0002-1267-0234;
+    npx:introduces <https://example.org/spaces/test-workshop> .
+}