diff --git a/tbx/blog/tests/test_models.py b/tbx/blog/tests/test_models.py
index c1756b602..aee01cd40 100644
--- a/tbx/blog/tests/test_models.py
+++ b/tbx/blog/tests/test_models.py
@@ -1,3 +1,4 @@
+import json
 from operator import attrgetter
 
 from django.core.paginator import Page as PaginatorPage
@@ -12,6 +13,7 @@
 from tbx.blog.models import BlogPage
 from tbx.core.factories import HomePageFactory
 from tbx.divisions.factories import DivisionPageFactory
+from tbx.people.factories import PersonPageFactory
 from tbx.taxonomy.factories import SectorFactory, ServiceFactory
 
 
@@ -133,3 +135,407 @@ def test_related_blog_posts_padded_if_not_enough(self):
             ],
             transform=attrgetter("title"),
         )
+
+
+class TestBlogPageJSONLD(WagtailPageTestCase):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        site = Site.objects.get(is_default_site=True)
+        root = site.root_page.specific
+        cls.homepage = HomePageFactory(parent=root)
+        cls.division = DivisionPageFactory(parent=cls.homepage, title="Charity")
+        cls.blog_index = BlogIndexPageFactory(parent=cls.division)
+
+        # Create a person page for the author
+        cls.author = PersonPageFactory(parent=cls.homepage, title="John Doe")
+
+        # Create a blog post with all the necessary fields for JSON-LD
+        cls.blog_post = BlogPageFactory(
+            parent=cls.blog_index,
+            title="Test Blog Post",
+            date="2024-01-15",
+            listing_summary="This is a test blog post summary",
+            search_description="SEO description for the blog post",
+        )
+
+        # Publish the blog post properly
+        cls.blog_post.save_revision().publish()
+
+        # Create an Author instance linked to the PersonPage
+        from tbx.people.factories import AuthorFactory
+
+        author = AuthorFactory(person_page=cls.author, name="John Doe")
+
+        # Add author to the blog post
+        from tbx.core.utils.models import PageAuthor
+
+        PageAuthor.objects.create(page=cls.blog_post, author=author)
+
+    def test_blog_posting_jsonld_renders(self):
+        """Test that BlogPosting JSON-LD is rendered in the blog detail template."""
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the blog posting JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/pages/blog/blog-posting-jsonld.html", context
+        )
+
+        # Check that the JSON-LD content is valid
+        self.assertIn("application/ld+json", jsonld_content)
+        self.assertIn("BlogPosting", jsonld_content)
+
+        # Parse the JSON to ensure it's valid
+        import json
+
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+        start_idx = jsonld_content.find(start_marker)
+        end_idx = jsonld_content.find(end_marker, start_idx)
+
+        if start_idx != -1 and end_idx != -1:
+            json_content = jsonld_content[
+                start_idx + len(start_marker) : end_idx
+            ].strip()
+            json_data = json.loads(json_content)
+            self.assertEqual(json_data["@type"], "BlogPosting")
+        else:
+            self.fail("JSON-LD script tag not found in rendered template")
+
+    def test_blog_posting_jsonld_structure(self):
+        """Test that BlogPosting JSON-LD contains all required fields."""
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the blog posting JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/pages/blog/blog-posting-jsonld.html", context
+        )
+
+        # Extract JSON-LD from the response
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+        start_idx = jsonld_content.find(start_marker)
+        end_idx = jsonld_content.find(end_marker, start_idx)
+
+        self.assertNotEqual(start_idx, -1, "JSON-LD script tag not found")
+        self.assertNotEqual(end_idx, -1, "JSON-LD script tag not properly closed")
+
+        json_content = jsonld_content[start_idx + len(start_marker) : end_idx].strip()
+        json_data = json.loads(json_content)
+
+        # Test required fields
+        self.assertEqual(json_data["@context"], "https://schema.org")
+        self.assertEqual(json_data["@type"], "BlogPosting")
+        self.assertEqual(json_data["headline"], "Test Blog Post")
+        self.assertEqual(json_data["datePublished"], "2024-01-15")
+
+        # Test mainEntityOfPage
+        self.assertIn("mainEntityOfPage", json_data)
+        self.assertEqual(json_data["mainEntityOfPage"]["@type"], "WebPage")
+
+        # Test publisher
+        self.assertIn("publisher", json_data)
+        self.assertEqual(json_data["publisher"]["@type"], "Organization")
+        self.assertEqual(json_data["publisher"]["name"], "Torchbox")
+
+        # Test author
+        self.assertIn("author", json_data)
+        self.assertEqual(json_data["author"]["@type"], "Person")
+        self.assertEqual(json_data["author"]["name"], "John Doe")
+
+    def test_blog_posting_jsonld_with_feed_image(self):
+        """Test BlogPosting JSON-LD includes image when feed_image is set."""
+        # Create an image for the blog post
+        from tbx.images.factories import CustomImageFactory
+
+        image = CustomImageFactory()
+        self.blog_post.feed_image = image
+        self.blog_post.save()
+
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the blog posting JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/pages/blog/blog-posting-jsonld.html", context
+        )
+
+        # Extract JSON-LD
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+        start_idx = jsonld_content.find(start_marker)
+        end_idx = jsonld_content.find(end_marker, start_idx)
+
+        json_content = jsonld_content[start_idx + len(start_marker) : end_idx].strip()
+        json_data = json.loads(json_content)
+
+        # Test that image is included
+        self.assertIn("image", json_data)
+        self.assertIn("format-webp", json_data["image"])
+
+    def test_blog_posting_jsonld_without_feed_image(self):
+        """Test BlogPosting JSON-LD works without feed_image."""
+        self.blog_post.feed_image = None
+        self.blog_post.save()
+
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the blog posting JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/pages/blog/blog-posting-jsonld.html", context
+        )
+
+        # Extract JSON-LD
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+        start_idx = jsonld_content.find(start_marker)
+        end_idx = jsonld_content.find(end_marker, start_idx)
+
+        json_content = jsonld_content[start_idx + len(start_marker) : end_idx].strip()
+        json_data = json.loads(json_content)
+
+        # Test that image is not included
+        self.assertNotIn("image", json_data)
+
+    def test_blog_posting_jsonld_description_fallback(self):
+        """Test that description falls back to listing_summary when search_description is not set."""
+        self.blog_post.search_description = ""
+        self.blog_post.save()
+
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the blog posting JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/pages/blog/blog-posting-jsonld.html", context
+        )
+
+        # Extract JSON-LD
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+        start_idx = jsonld_content.find(start_marker)
+        end_idx = jsonld_content.find(end_marker, start_idx)
+
+        json_content = jsonld_content[start_idx + len(start_marker) : end_idx].strip()
+        json_data = json.loads(json_content)
+
+        # Test that description uses listing_summary as fallback
+        self.assertEqual(json_data["description"], "This is a test blog post summary")
+
+    def test_blog_posting_jsonld_date_modified(self):
+        """Test that dateModified is set correctly."""
+        # Update the blog post to trigger last_published_at
+        self.blog_post.title = "Updated Title"
+        self.blog_post.save()
+
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the blog posting JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/pages/blog/blog-posting-jsonld.html", context
+        )
+
+        # Extract JSON-LD
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+        start_idx = jsonld_content.find(start_marker)
+        end_idx = jsonld_content.find(end_marker, start_idx)
+
+        json_content = jsonld_content[start_idx + len(start_marker) : end_idx].strip()
+        json_data = json.loads(json_content)
+
+        # Test that dateModified is present
+        self.assertIn("dateModified", json_data)
+        # Should be in YYYY-MM-DD format
+        self.assertRegex(json_data["dateModified"], r"^\d{4}-\d{2}-\d{2}$")
+
+
+class TestBreadcrumbJSONLD(WagtailPageTestCase):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        site = Site.objects.get(is_default_site=True)
+        root = site.root_page.specific
+        cls.homepage = HomePageFactory(parent=root)
+        cls.division = DivisionPageFactory(parent=cls.homepage, title="Charity")
+        cls.blog_index = BlogIndexPageFactory(parent=cls.division, title="Blog")
+        cls.blog_post = BlogPageFactory(parent=cls.blog_index, title="Test Blog Post")
+
+    def test_breadcrumb_jsonld_renders(self):
+        """Test that breadcrumb JSON-LD is rendered in the blog detail template."""
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the breadcrumb JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/navigation/components/breadcrumbs-jsonld.html", context
+        )
+
+        # Check that the JSON-LD content is valid
+        self.assertIn("application/ld+json", jsonld_content)
+        self.assertIn("BreadcrumbList", jsonld_content)
+
+    def test_breadcrumb_jsonld_structure(self):
+        """Test that breadcrumb JSON-LD contains correct structure."""
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the breadcrumb JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/navigation/components/breadcrumbs-jsonld.html", context
+        )
+
+        # Extract breadcrumb JSON-LD from the response
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+
+        # Find all JSON-LD scripts and look for the breadcrumb one
+        json_scripts = []
+        start_idx = 0
+        while True:
+            start_idx = jsonld_content.find(start_marker, start_idx)
+            if start_idx == -1:
+                break
+            end_idx = jsonld_content.find(end_marker, start_idx)
+            if end_idx == -1:
+                break
+
+            json_content = jsonld_content[
+                start_idx + len(start_marker) : end_idx
+            ].strip()
+            try:
+                json_data = json.loads(json_content)
+                if json_data.get("@type") == "BreadcrumbList":
+                    json_scripts.append(json_data)
+            except json.JSONDecodeError:
+                pass
+            start_idx = end_idx + len(end_marker)
+
+        self.assertGreater(len(json_scripts), 0, "BreadcrumbList JSON-LD not found")
+
+        breadcrumb_data = json_scripts[0]
+
+        # Test required fields
+        self.assertEqual(breadcrumb_data["@context"], "https://schema.org/")
+        self.assertEqual(breadcrumb_data["@type"], "BreadcrumbList")
+        self.assertIn("itemListElement", breadcrumb_data)
+
+        # Test that we have the expected breadcrumb items
+        items = breadcrumb_data["itemListElement"]
+        self.assertGreater(len(items), 0, "No breadcrumb items found")
+
+        # Test first item (should be Charity based on the breadcrumb structure)
+        first_item = items[0]
+        self.assertEqual(first_item["@type"], "ListItem")
+        self.assertEqual(first_item["position"], 1)
+        self.assertEqual(first_item["name"], "Charity")
+
+        # Test that all items have required fields
+        for i, item in enumerate(items):
+            self.assertEqual(item["@type"], "ListItem")
+            self.assertEqual(item["position"], i + 1)
+            self.assertIn("name", item)
+            self.assertIn("item", item)
+
+    def test_breadcrumb_jsonld_with_division(self):
+        """Test breadcrumb JSON-LD includes division page."""
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the breadcrumb JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/navigation/components/breadcrumbs-jsonld.html", context
+        )
+
+        # Extract breadcrumb JSON-LD
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+
+        json_scripts = []
+        start_idx = 0
+        while True:
+            start_idx = jsonld_content.find(start_marker, start_idx)
+            if start_idx == -1:
+                break
+            end_idx = jsonld_content.find(end_marker, start_idx)
+            if end_idx == -1:
+                break
+
+            json_content = jsonld_content[
+                start_idx + len(start_marker) : end_idx
+            ].strip()
+            try:
+                json_data = json.loads(json_content)
+                if json_data.get("@type") == "BreadcrumbList":
+                    json_scripts.append(json_data)
+            except json.JSONDecodeError:
+                pass
+            start_idx = end_idx + len(end_marker)
+
+        breadcrumb_data = json_scripts[0]
+        items = breadcrumb_data["itemListElement"]
+
+        # Should have at least Division and Blog Index
+        self.assertGreaterEqual(len(items), 2)
+
+        # Check that division is included
+        division_names = [item["name"] for item in items]
+        self.assertIn("Charity", division_names)
+
+    def test_breadcrumb_jsonld_urls(self):
+        """Test that breadcrumb JSON-LD contains URL structure."""
+        # Test the JSON-LD template directly instead of through URL
+        from django.template.loader import render_to_string
+
+        # Render the breadcrumb JSON-LD template directly
+        context = {"page": self.blog_post}
+        jsonld_content = render_to_string(
+            "patterns/navigation/components/breadcrumbs-jsonld.html", context
+        )
+
+        # Extract breadcrumb JSON-LD
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+
+        json_scripts = []
+        start_idx = 0
+        while True:
+            start_idx = jsonld_content.find(start_marker, start_idx)
+            if start_idx == -1:
+                break
+            end_idx = jsonld_content.find(end_marker, start_idx)
+            if end_idx == -1:
+                break
+
+            json_content = jsonld_content[
+                start_idx + len(start_marker) : end_idx
+            ].strip()
+            try:
+                json_data = json.loads(json_content)
+                if json_data.get("@type") == "BreadcrumbList":
+                    json_scripts.append(json_data)
+            except json.JSONDecodeError:
+                pass
+            start_idx = end_idx + len(end_marker)
+
+        breadcrumb_data = json_scripts[0]
+        items = breadcrumb_data["itemListElement"]
+
+        # Test that all items have item field (URL structure)
+        for item in items:
+            self.assertIn("item", item)
+            # In test environment, URLs might be None, so just check the field exists
+            self.assertIsNotNone(item["item"])
diff --git a/tbx/core/tests/test_jsonld.py b/tbx/core/tests/test_jsonld.py
new file mode 100644
index 000000000..702e56da5
--- /dev/null
+++ b/tbx/core/tests/test_jsonld.py
@@ -0,0 +1,228 @@
+import json
+
+from django.template.loader import get_template, render_to_string
+from django.test import RequestFactory
+
+from wagtail.contrib.settings.context_processors import settings as settings_processor
+from wagtail.models import Site
+from wagtail.test.utils import WagtailPageTestCase
+
+from tbx.blog.factories import BlogIndexPageFactory, BlogPageFactory
+from tbx.core.factories import HomePageFactory
+from tbx.divisions.factories import DivisionPageFactory
+
+
+class TestOrganizationJSONLD(WagtailPageTestCase):
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        site = Site.objects.get(is_default_site=True)
+        root = site.root_page.specific
+        cls.homepage = HomePageFactory(
+            parent=root,
+            title="Torchbox",
+            hero_heading_1="Welcome to",
+            hero_heading_2="Torchbox",
+        )
+
+    def _get_template_context(self, page):
+        """Helper method to create proper template context with settings."""
+        factory = RequestFactory()
+        request = factory.get("/")
+        settings_context = settings_processor(request)
+
+        return {"page": page, "request": request, **settings_context}
+
+    def _extract_jsonld_by_type(self, content, jsonld_type):
+        """Helper method to extract JSON-LD by type from rendered content."""
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+
+        json_scripts = []
+        start_idx = 0
+        while True:
+            start_idx = content.find(start_marker, start_idx)
+            if start_idx == -1:
+                break
+            end_idx = content.find(end_marker, start_idx)
+            if end_idx == -1:
+                break
+
+            json_content = content[start_idx + len(start_marker) : end_idx].strip()
+            try:
+                json_data = json.loads(json_content)
+                if json_data.get("@type") == jsonld_type:
+                    json_scripts.append(json_data)
+            except json.JSONDecodeError:
+                pass
+            start_idx = end_idx + len(end_marker)
+
+        return json_scripts
+
+    def _get_organization_jsonld(self):
+        """Helper method to get Organization JSON-LD from homepage."""
+        context = self._get_template_context(self.homepage)
+        content = render_to_string("patterns/pages/home/home_page.html", context)
+        json_scripts = self._extract_jsonld_by_type(content, "Organization")
+        self.assertGreater(len(json_scripts), 0, "Organization JSON-LD not found")
+        return json_scripts[0]
+
+    def test_organization_jsonld_renders(self):
+        """Test that Organization JSON-LD is rendered on the homepage."""
+        org_data = self._get_organization_jsonld()
+        self.assertEqual(org_data["@type"], "Organization")
+
+    def test_organization_jsonld_structure(self):
+        """Test that Organization JSON-LD contains all required fields."""
+        org_data = self._get_organization_jsonld()
+
+        # Test required fields
+        self.assertEqual(org_data["@context"], "https://schema.org")
+        self.assertEqual(org_data["@type"], "Organization")
+        self.assertEqual(org_data["name"], "Torchbox")
+        self.assertEqual(org_data["url"], "https://torchbox.com/")
+
+        # Test logo
+        self.assertIn("logo", org_data)
+        self.assertEqual(
+            org_data["logo"], "https://torchbox.com/android-chrome-512x512.png"
+        )
+
+        # Test social media links
+        self.assertIn("sameAs", org_data)
+        same_as = org_data["sameAs"]
+        self.assertIsInstance(same_as, list)
+        self.assertGreater(len(same_as), 0)
+
+        # Check for expected social media links
+        expected_links = [
+            "https://bsky.app/profile/torchbox.com",
+            "https://www.linkedin.com/company/torchbox",
+            "https://www.instagram.com/torchboxltd/",
+        ]
+        for link in expected_links:
+            self.assertIn(link, same_as)
+
+    def test_organization_jsonld_social_links(self):
+        """Test that Organization JSON-LD includes correct social media links."""
+        org_data = self._get_organization_jsonld()
+        same_as = org_data["sameAs"]
+
+        # Test that all social links are valid URLs
+        for link in same_as:
+            self.assertTrue(link.startswith("http"), f"Invalid social link: {link}")
+
+        # Test that we have the expected number of social links
+        self.assertGreaterEqual(len(same_as), 3)
+
+    def test_organization_jsonld_logo_url(self):
+        """Test that Organization JSON-LD includes correct logo URL."""
+        org_data = self._get_organization_jsonld()
+        logo_url = org_data["logo"]
+
+        # Test that logo URL is correct
+        self.assertEqual(logo_url, "https://torchbox.com/android-chrome-512x512.png")
+        self.assertTrue(logo_url.startswith("https://"), "Logo URL should be HTTPS")
+
+
+class TestJSONLDTemplateInclusion(WagtailPageTestCase):
+    """Test that JSON-LD templates are properly included in page renders."""
+
+    @classmethod
+    def setUpTestData(cls):
+        super().setUpTestData()
+        site = Site.objects.get(is_default_site=True)
+        root = site.root_page.specific
+        cls.homepage = HomePageFactory(parent=root)
+        cls.division = DivisionPageFactory(parent=cls.homepage, title="Charity")
+        cls.blog_index = BlogIndexPageFactory(parent=cls.division, title="Blog")
+        cls.blog_post = BlogPageFactory(parent=cls.blog_index, title="Test Blog Post")
+
+    def _get_template_context(self, page):
+        """Helper method to create proper template context with settings."""
+        factory = RequestFactory()
+        request = factory.get("/")
+        settings_context = settings_processor(request)
+
+        return {"page": page, "request": request, **settings_context}
+
+    def _extract_jsonld_by_type(self, content, jsonld_type):
+        """Helper method to extract JSON-LD by type from rendered content."""
+        start_marker = '<script type="application/ld+json">'
+        end_marker = "</script>"
+
+        json_scripts = []
+        start_idx = 0
+        while True:
+            start_idx = content.find(start_marker, start_idx)
+            if start_idx == -1:
+                break
+            end_idx = content.find(end_marker, start_idx)
+            if end_idx == -1:
+                break
+
+            json_content = content[start_idx + len(start_marker) : end_idx].strip()
+            try:
+                json_data = json.loads(json_content)
+                if json_data.get("@type") == jsonld_type:
+                    json_scripts.append(json_data)
+            except json.JSONDecodeError:
+                pass
+            start_idx = end_idx + len(end_marker)
+
+        return json_scripts
+
+    def _get_organization_jsonld(self):
+        """Helper method to get Organization JSON-LD from homepage."""
+        context = self._get_template_context(self.homepage)
+        content = render_to_string("patterns/pages/home/home_page.html", context)
+        json_scripts = self._extract_jsonld_by_type(content, "Organization")
+        self.assertGreater(len(json_scripts), 0, "Organization JSON-LD not found")
+        return json_scripts[0]
+
+    def test_base_template_includes_jsonld_block(self):
+        """Test that the base template includes the extra_jsonld block."""
+        org_data = self._get_organization_jsonld()
+        self.assertEqual(org_data["@type"], "Organization")
+
+    def test_breadcrumb_template_included(self):
+        """Test that breadcrumb JSON-LD template is included."""
+        # Render the breadcrumb JSON-LD template directly
+        context = {"page": self.blog_post, "request": RequestFactory().get("/")}
+        content = render_to_string(
+            "patterns/navigation/components/breadcrumbs-jsonld.html", context
+        )
+
+        # Check that breadcrumb JSON-LD content is present
+        self.assertIn("application/ld+json", content)
+        self.assertIn("BreadcrumbList", content)
+
+    def test_blog_posting_template_included(self):
+        """Test that blog posting JSON-LD template is included for blog pages."""
+        # This test would need to be run on an actual blog page
+        # For now, we'll just verify the template exists
+        try:
+            template = get_template("patterns/pages/blog/blog-posting-jsonld.html")
+            self.assertIsNotNone(template)
+        except Exception as e:
+            self.fail(f"Blog posting JSON-LD template not found: {e}")
+
+    def test_breadcrumb_template_exists(self):
+        """Test that breadcrumb JSON-LD template exists."""
+        try:
+            template = get_template(
+                "patterns/navigation/components/breadcrumbs-jsonld.html"
+            )
+            self.assertIsNotNone(template)
+        except Exception as e:
+            self.fail(f"Breadcrumb JSON-LD template not found: {e}")
+
+    def test_jsonld_script_tags_present(self):
+        """Test that JSON-LD script tags are present in the rendered HTML."""
+        org_data = self._get_organization_jsonld()
+        self.assertIsNotNone(org_data)
+
+    def test_multiple_jsonld_scripts(self):
+        """Test that multiple JSON-LD scripts can be present on a page."""
+        org_data = self._get_organization_jsonld()
+        self.assertEqual(org_data["@type"], "Organization")
diff --git a/tbx/project_styleguide/templates/patterns/base.html b/tbx/project_styleguide/templates/patterns/base.html
index 699431601..ea1be6f36 100644
--- a/tbx/project_styleguide/templates/patterns/base.html
+++ b/tbx/project_styleguide/templates/patterns/base.html
@@ -29,6 +29,10 @@
 
         {% block meta_tags %}{% endblock %}
 
+        {% include "patterns/navigation/components/breadcrumbs-jsonld.html" %}
+
+        {% block extra_jsonld %}{% endblock %}
+
         <link rel="stylesheet" type="text/css" href="{% static 'css/main.css' %}">
 
         {# Add syntax highlighting for gists if a gist exists within a raw html streamfield #}
diff --git a/tbx/project_styleguide/templates/patterns/navigation/components/breadcrumbs-jsonld.html b/tbx/project_styleguide/templates/patterns/navigation/components/breadcrumbs-jsonld.html
new file mode 100644
index 000000000..c131b161b
--- /dev/null
+++ b/tbx/project_styleguide/templates/patterns/navigation/components/breadcrumbs-jsonld.html
@@ -0,0 +1,17 @@
+{% load wagtailcore_tags %}
+{% if page.breadcrumbs %}
+    <script type="application/ld+json">
+        {
+            "@context": "https://schema.org/",
+            "@type": "BreadcrumbList",
+            "itemListElement": [{% for crumb in page.breadcrumbs %}
+                {
+                    "@type": "ListItem",
+                    "position": {{ forloop.counter }},
+                    "name": "{% if crumb.depth == 2 %}Home{% else %}{{ crumb.title|escapejs }}{% endif %}",
+                    "item": "{% fullpageurl crumb %}"
+                }{% if not forloop.last %},{% endif %}{% endfor %}
+            ]
+        }
+    </script>
+{% endif %}
diff --git a/tbx/project_styleguide/templates/patterns/pages/blog/blog-posting-jsonld.html b/tbx/project_styleguide/templates/patterns/pages/blog/blog-posting-jsonld.html
new file mode 100644
index 000000000..71100dd93
--- /dev/null
+++ b/tbx/project_styleguide/templates/patterns/pages/blog/blog-posting-jsonld.html
@@ -0,0 +1,29 @@
+{% load wagtailcore_tags wagtailimages_tags %}
+<script type="application/ld+json">
+    {
+        "@context": "https://schema.org",
+        "@type": "BlogPosting",
+        "mainEntityOfPage": {
+            "@type": "WebPage",
+            "@id": "{% fullpageurl page %}"
+        },
+        "headline": "{{ page.title|escapejs }}",
+        "description": "{% if page.search_description %}{{ page.search_description|escapejs }}{% elif page.listing_summary %}{{ page.listing_summary|escapejs }}{% endif %}"{% if page.feed_image %},
+            "image": "{% image page.feed_image format-webp width-1200 as blog_image %}{{ blog_image.url }}"{% endif %}{% if page.first_author %},
+                "author": {
+                    "@type": "Person",
+                    "name": "{{ page.first_author.name|escapejs }}"{% if page.first_author.person_page %},
+                        "url": "{% fullpageurl page.first_author.person_page %}"{% endif %}
+                }{% endif %},
+        "publisher": {
+            "@type": "Organization",
+            "name": "Torchbox",
+            "logo": {
+                "@type": "ImageObject",
+                "url": "{% wagtail_site as current_site %}{{ current_site.root_url }}/apple-touch-icon.png"
+            }
+        },
+        "datePublished": "{{ page.date|date:'Y-m-d' }}",
+        "dateModified": "{% if page.last_published_at %}{{ page.last_published_at|date:'Y-m-d' }}{% else %}{{ page.date|date:'Y-m-d' }}{% endif %}"
+    }
+</script>
diff --git a/tbx/project_styleguide/templates/patterns/pages/blog/blog_detail.html b/tbx/project_styleguide/templates/patterns/pages/blog/blog_detail.html
index b87f5885f..c8462bce7 100644
--- a/tbx/project_styleguide/templates/patterns/pages/blog/blog_detail.html
+++ b/tbx/project_styleguide/templates/patterns/pages/blog/blog_detail.html
@@ -22,6 +22,10 @@
     {{ block.super }}
 {% endblock %}
 
+{% block extra_jsonld %}
+    {% include "patterns/pages/blog/blog-posting-jsonld.html" %}
+{% endblock %}
+
 {% block content %}
     <div class="grid grid--spacer-large streamfield lg:relative">
         <div class="authors">
diff --git a/tbx/project_styleguide/templates/patterns/pages/home/home_page.html b/tbx/project_styleguide/templates/patterns/pages/home/home_page.html
index 23c3f3a6d..e9402dd93 100644
--- a/tbx/project_styleguide/templates/patterns/pages/home/home_page.html
+++ b/tbx/project_styleguide/templates/patterns/pages/home/home_page.html
@@ -1,6 +1,23 @@
 {% extends "patterns/base_page.html" %}
 {% load wagtailcore_tags wagtailimages_tags navigation_tags static %}
 
+{% block extra_jsonld %}
+    <script type="application/ld+json">
+        {
+            "@context": "https://schema.org",
+            "@type": "Organization",
+            "name": "Torchbox",
+            "url": "https://torchbox.com/",
+            "logo": "https://torchbox.com/android-chrome-512x512.png",
+            "sameAs": [
+                "https://bsky.app/profile/torchbox.com",
+                "https://www.linkedin.com/company/torchbox",
+                "https://www.instagram.com/torchboxltd/"
+            ]
+        }
+    </script>
+{% endblock extra_jsonld %}
+
 {% block content %}
 
     <div class="swirls">