diff --git a/README.md b/README.md
index 2ecca46..7653fb2 100644
--- a/README.md
+++ b/README.md
@@ -161,6 +161,38 @@ If your hubs are in external assemblies, you can specify them:
 app.AddHubDocs(typeof(ExternalHub).Assembly);
 ```
 
+### Document Metadata Options
+
+You can pass metadata (similar to Swagger `info`) that appears in `hubdocs.json` and in the HubDocs UI header:
+
+```csharp
+app.AddHubDocs(options =>
+{
+  options.Title = "My SignalR API";
+  options.Version = "1.0.0";
+  options.Description = "Realtime messaging API docs.";
+  options.ProjectUrl = "https://example.com/project";
+  options.TermsOfService = "https://example.com/terms";
+
+  options.Contact.Name = "API Support";
+  options.Contact.Email = "support@example.com";
+  options.Contact.Url = "https://example.com/support";
+
+  options.License.Name = "MIT";
+  options.License.Url = "https://example.com/license";
+});
+```
+
+You can combine options with custom assembly scanning:
+
+```csharp
+app.AddHubDocs(options =>
+{
+  options.Title = "External Hubs API";
+  options.Version = "2.0.0";
+}, typeof(ExternalHub).Assembly);
+```
+
 ### Opt-in Documentation
 
 Only hubs marked with `[HubDocs]` attribute will appear in the documentation UI. This gives you control over which hubs are publicly documented.
diff --git a/samples/HubDocs.Sample/Program.cs b/samples/HubDocs.Sample/Program.cs
index 97e98e7..18f6581 100644
--- a/samples/HubDocs.Sample/Program.cs
+++ b/samples/HubDocs.Sample/Program.cs
@@ -30,7 +30,21 @@
 app.MapHub<NotificationHub>("/hubs/notifications");
 
 // Configure HubDocs - discovers hubs with [HubDocs] attribute from registered endpoints
-app.AddHubDocs();
+app.AddHubDocs(options =>
+{
+    options.Title = "HubDocs Sample SignalR API";
+    options.Version = "1.0.0";
+    options.Description = "Sample project showing HubDocs rich JSON export and interactive SignalR hub explorer.";
+    options.ProjectUrl = "https://github.com/mberrishdev/HubDocs";
+    options.TermsOfService = "https://github.com/mberrishdev/HubDocs/blob/main/LICENSE";
+
+    options.Contact.Name = "HubDocs Team";
+    options.Contact.Email = "support@hubdocs.dev";
+    options.Contact.Url = "https://github.com/mberrishdev/HubDocs/issues";
+
+    options.License.Name = "MIT";
+    options.License.Url = "https://github.com/mberrishdev/HubDocs/blob/main/LICENSE";
+});
 
 app.MapControllers();
 
diff --git a/src/HubDocs/Extensions.cs b/src/HubDocs/Extensions.cs
index 5db03c1..23cc68f 100644
--- a/src/HubDocs/Extensions.cs
+++ b/src/HubDocs/Extensions.cs
@@ -13,11 +13,20 @@ public static class Extensions
 
     public static WebApplication AddHubDocs(this WebApplication app, params Assembly[] additionalAssemblies)
     {
+        return AddHubDocs(app, _ => { }, additionalAssemblies);
+    }
+
+    public static WebApplication AddHubDocs(this WebApplication app, Action<HubDocsDocumentOptions> configureDocument, params Assembly[] additionalAssemblies)
+    {
+        var documentOptions = new HubDocsDocumentOptions();
+        configureDocument(documentOptions);
+
         app.MapGet("/hubdocs/hubdocs.json", () =>
             {
                 var hubRoutes = GetHubRoutesFromEndpoints(app);
-                var metadata = DiscoverSignalRHubs(hubRoutes, additionalAssemblies);
-                return Results.Ok(metadata);
+                var metadata = DiscoverSignalRHubs(hubRoutes, additionalAssemblies).ToList();
+                var hubDocsDocument = BuildHubDocsDocument(metadata, documentOptions);
+                return Results.Ok(hubDocsDocument);
             })
             .ExcludeFromDescription();
 
@@ -439,6 +448,279 @@ private static string BuildReturnExample(MethodInfo method)
         return CreateExampleLiteral(unwrapped, false);
     }
 
+    private static Dictionary<string, object?> BuildHubDocsDocument(IReadOnlyList<HubMetadata> hubs)
+    {
+        return BuildHubDocsDocument(hubs, new HubDocsDocumentOptions());
+    }
+
+    private static Dictionary<string, object?> BuildHubDocsDocument(IReadOnlyList<HubMetadata> hubs, HubDocsDocumentOptions options)
+    {
+        var channels = new Dictionary<string, object?>();
+        var messages = new Dictionary<string, object?>();
+        var schemas = new Dictionary<string, object?>();
+
+        foreach (var hub in hubs)
+        {
+            if (string.IsNullOrWhiteSpace(hub.Path))
+                continue;
+
+            foreach (var schema in hub.Schemas)
+            {
+                if (schemas.ContainsKey(schema.Name))
+                    continue;
+
+                schemas[schema.Name] = ConvertHubSchemaToProtocolSchema(schema);
+            }
+
+            var publishMessageRefs = new List<object>();
+            foreach (var method in hub.Methods)
+            {
+                var messageName = $"{hub.HubName}.{method.MethodName}.Request";
+                messages[messageName] = BuildMethodMessage(messageName, method, schemas.Keys);
+                publishMessageRefs.Add(new Dictionary<string, object?>
+                {
+                    ["$ref"] = $"#/components/messages/{messageName}"
+                });
+            }
+
+            var subscribeMessageRefs = new List<object>();
+            foreach (var method in hub.ClientMethods ?? [])
+            {
+                var messageName = $"{hub.HubName}.{method.MethodName}.Event";
+                messages[messageName] = BuildMethodMessage(messageName, method, schemas.Keys);
+                subscribeMessageRefs.Add(new Dictionary<string, object?>
+                {
+                    ["$ref"] = $"#/components/messages/{messageName}"
+                });
+            }
+
+            channels[hub.Path] = new Dictionary<string, object?>
+            {
+                ["publish"] = new Dictionary<string, object?>
+                {
+                    ["operationId"] = $"{hub.HubName}.publish",
+                    ["summary"] = $"Client-to-server methods for {hub.HubName}",
+                    ["message"] = new Dictionary<string, object?>
+                    {
+                        ["oneOf"] = publishMessageRefs
+                    }
+                },
+                ["subscribe"] = new Dictionary<string, object?>
+                {
+                    ["operationId"] = $"{hub.HubName}.subscribe",
+                    ["summary"] = $"Server-to-client methods for {hub.HubName}",
+                    ["message"] = new Dictionary<string, object?>
+                    {
+                        ["oneOf"] = subscribeMessageRefs
+                    }
+                }
+            };
+        }
+
+        return new Dictionary<string, object?>
+        {
+            ["hubdocs"] = new Dictionary<string, object?>
+            {
+                ["format"] = "hubdocs-1.0",
+                ["version"] = options.Version,
+                ["title"] = options.Title,
+                ["description"] = options.Description,
+                ["termsOfService"] = options.TermsOfService,
+                ["projectUrl"] = options.ProjectUrl,
+                ["contact"] = new Dictionary<string, object?>
+                {
+                    ["name"] = options.Contact.Name,
+                    ["email"] = options.Contact.Email,
+                    ["url"] = options.Contact.Url
+                },
+                ["license"] = new Dictionary<string, object?>
+                {
+                    ["name"] = options.License.Name,
+                    ["url"] = options.License.Url
+                },
+                ["generatedAtUtc"] = DateTime.UtcNow.ToString("O")
+            },
+            ["hubs"] = hubs,
+            ["channels"] = channels,
+            ["components"] = new Dictionary<string, object?>
+            {
+                ["messages"] = messages,
+                ["schemas"] = schemas
+            }
+        };
+    }
+
+    private static Dictionary<string, object?> BuildMethodMessage(string messageName, HubMethodMetadata method, IEnumerable<string> knownSchemas)
+    {
+        var argumentProperties = new Dictionary<string, object?>();
+
+        foreach (var parameter in method.Parameters)
+        {
+            argumentProperties[parameter.Name] = BuildJsonSchemaForType(parameter.Type, knownSchemas, parameter.Example, parameter.IsNullable);
+        }
+
+        var payloadProperties = new Dictionary<string, object?>
+        {
+            ["method"] = new Dictionary<string, object?>
+            {
+                ["type"] = "string",
+                ["example"] = method.MethodName
+            },
+            ["arguments"] = new Dictionary<string, object?>
+            {
+                ["type"] = "object",
+                ["properties"] = argumentProperties
+            },
+            ["returns"] = BuildJsonSchemaForType(method.ReturnType, knownSchemas, method.ReturnExample, false)
+        };
+
+        return new Dictionary<string, object?>
+        {
+            ["name"] = messageName,
+            ["title"] = method.Signature,
+            ["payload"] = new Dictionary<string, object?>
+            {
+                ["type"] = "object",
+                ["properties"] = payloadProperties,
+                ["required"] = new[] { "method", "arguments" }
+            },
+            ["examples"] = new[]
+            {
+                new Dictionary<string, object?>
+                {
+                    ["name"] = $"{method.MethodName}Example",
+                    ["summary"] = method.Signature,
+                    ["payload"] = new Dictionary<string, object?>
+                    {
+                        ["method"] = method.MethodName,
+                        ["arguments"] = method.Parameters.ToDictionary(p => p.Name, p => (object?)p.Example),
+                        ["returns"] = method.ReturnExample
+                    }
+                }
+            }
+        };
+    }
+
+    private static Dictionary<string, object?> BuildJsonSchemaForType(string csharpType, IEnumerable<string> knownSchemas, string? example, bool nullable)
+    {
+        var cleaned = csharpType.Trim();
+        if (cleaned.EndsWith("?", StringComparison.Ordinal))
+        {
+            cleaned = cleaned[..^1];
+            nullable = true;
+        }
+
+        if (cleaned.EndsWith("[]", StringComparison.Ordinal))
+        {
+            var itemType = cleaned[..^2];
+            var itemSchema = BuildJsonSchemaForType(itemType, knownSchemas, null, false);
+            var arraySchema = new Dictionary<string, object?>
+            {
+                ["type"] = "array",
+                ["items"] = itemSchema
+            };
+
+            if (example != null)
+                arraySchema["example"] = example;
+
+            if (nullable)
+                arraySchema["nullable"] = true;
+
+            return arraySchema;
+        }
+
+        if (cleaned.StartsWith("List<", StringComparison.Ordinal) && cleaned.EndsWith(">", StringComparison.Ordinal))
+        {
+            var inner = cleaned[5..^1];
+            var itemSchema = BuildJsonSchemaForType(inner, knownSchemas, null, false);
+            var listSchema = new Dictionary<string, object?>
+            {
+                ["type"] = "array",
+                ["items"] = itemSchema
+            };
+
+            if (example != null)
+                listSchema["example"] = example;
+
+            if (nullable)
+                listSchema["nullable"] = true;
+
+            return listSchema;
+        }
+
+        var schemaName = cleaned.Contains('<')
+            ? cleaned[..cleaned.IndexOf('<')]
+            : cleaned;
+
+        if (knownSchemas.Contains(schemaName, StringComparer.Ordinal))
+        {
+            var refSchema = new Dictionary<string, object?>
+            {
+                ["$ref"] = $"#/components/schemas/{schemaName}"
+            };
+
+            if (nullable)
+                refSchema["nullable"] = true;
+
+            return refSchema;
+        }
+
+        var primitive = MapPrimitiveJsonSchema(cleaned);
+        if (example != null)
+            primitive["example"] = example;
+        if (nullable)
+            primitive["nullable"] = true;
+        return primitive;
+    }
+
+    private static Dictionary<string, object?> MapPrimitiveJsonSchema(string csharpType)
+    {
+        return csharpType switch
+        {
+            "bool" => new Dictionary<string, object?> { ["type"] = "boolean" },
+            "byte" or "sbyte" or "short" or "ushort" or "int" or "uint" or "long" or "ulong" =>
+                new Dictionary<string, object?> { ["type"] = "integer", ["format"] = "int64" },
+            "float" => new Dictionary<string, object?> { ["type"] = "number", ["format"] = "float" },
+            "double" or "decimal" => new Dictionary<string, object?> { ["type"] = "number", ["format"] = "double" },
+            "Guid" => new Dictionary<string, object?> { ["type"] = "string", ["format"] = "uuid" },
+            "DateTime" or "DateTimeOffset" => new Dictionary<string, object?> { ["type"] = "string", ["format"] = "date-time" },
+            "TimeSpan" => new Dictionary<string, object?> { ["type"] = "string" },
+            "Task" or "void" => new Dictionary<string, object?> { ["type"] = "null" },
+            _ => new Dictionary<string, object?> { ["type"] = "string" }
+        };
+    }
+
+    private static Dictionary<string, object?> ConvertHubSchemaToProtocolSchema(HubTypeSchemaMetadata schema)
+    {
+        if (schema.Kind == "enum")
+        {
+            var enumNames = (schema.EnumValues ?? [])
+                .Select(v => v.Split('=')[0].Trim())
+                .Where(v => !string.IsNullOrWhiteSpace(v))
+                .ToList();
+
+            return new Dictionary<string, object?>
+            {
+                ["type"] = "string",
+                ["enum"] = enumNames,
+                ["example"] = enumNames.FirstOrDefault()
+            };
+        }
+
+        var properties = new Dictionary<string, object?>();
+        foreach (var property in schema.Properties ?? [])
+        {
+            properties[property.Name] = BuildJsonSchemaForType(property.Type, [], property.Example, property.IsNullable);
+        }
+
+        return new Dictionary<string, object?>
+        {
+            ["type"] = "object",
+            ["properties"] = properties,
+            ["example"] = schema.Example
+        };
+    }
+
     private static string CreateExampleLiteral(Type type, bool nullable)
     {
         if (nullable)
diff --git a/src/HubDocs/HubDocs.csproj b/src/HubDocs/HubDocs.csproj
index 60dbc81..341727e 100644
--- a/src/HubDocs/HubDocs.csproj
+++ b/src/HubDocs/HubDocs.csproj
@@ -6,7 +6,7 @@
 
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <PackageId>HubDocs</PackageId>
-        <Version>0.0.8</Version>
+        <Version>0.0.9</Version>
         <Company>BerrishDev</Company>
         <Product>HubDocs</Product>
         <Description>Swagger-like documentation UI for SignalR Hubs</Description>
diff --git a/src/HubDocs/HubDocsDocumentOptions.cs b/src/HubDocs/HubDocsDocumentOptions.cs
new file mode 100644
index 0000000..8d55e5e
--- /dev/null
+++ b/src/HubDocs/HubDocsDocumentOptions.cs
@@ -0,0 +1,25 @@
+namespace HubDocs;
+
+public class HubDocsDocumentOptions
+{
+    public string Title { get; set; } = "HubDocs SignalR Protocol";
+    public string Version { get; set; } = "1.0.0";
+    public string? Description { get; set; } = "HubDocs protocol export with channels, messages, and schemas.";
+    public string? TermsOfService { get; set; }
+    public string? ProjectUrl { get; set; }
+    public HubDocsContactOptions Contact { get; set; } = new();
+    public HubDocsLicenseOptions License { get; set; } = new();
+}
+
+public class HubDocsContactOptions
+{
+    public string? Name { get; set; }
+    public string? Email { get; set; }
+    public string? Url { get; set; }
+}
+
+public class HubDocsLicenseOptions
+{
+    public string? Name { get; set; }
+    public string? Url { get; set; }
+}
diff --git a/src/HubDocs/README.md b/src/HubDocs/README.md
index ec0c7be..47be966 100644
--- a/src/HubDocs/README.md
+++ b/src/HubDocs/README.md
@@ -133,6 +133,38 @@ Scan specific assemblies for hubs:
 app.AddHubDocs(typeof(ExternalHub).Assembly);
 ```
 
+### Document Metadata Options
+
+You can configure project metadata (Swagger-like `info`) for HubDocs JSON and UI:
+
+```csharp
+app.AddHubDocs(options =>
+{
+  options.Title = "My SignalR API";
+  options.Version = "1.0.0";
+  options.Description = "Realtime messaging API docs.";
+  options.ProjectUrl = "https://example.com/project";
+  options.TermsOfService = "https://example.com/terms";
+
+  options.Contact.Name = "API Support";
+  options.Contact.Email = "support@example.com";
+  options.Contact.Url = "https://example.com/support";
+
+  options.License.Name = "MIT";
+  options.License.Url = "https://example.com/license";
+});
+```
+
+You can also combine metadata options with explicit assemblies:
+
+```csharp
+app.AddHubDocs(options =>
+{
+  options.Title = "External Hubs API";
+  options.Version = "2.0.0";
+}, typeof(ExternalHub).Assembly);
+```
+
 ### Opt-in with Attribute
 
 Only hubs marked with `[HubDocs]` attribute are documented. This provides control over which hubs appear in the UI.
diff --git a/src/HubDocs/wwwroot/hubdocs.html b/src/HubDocs/wwwroot/hubdocs.html
index 8eeb35e..38766bd 100644
--- a/src/HubDocs/wwwroot/hubdocs.html
+++ b/src/HubDocs/wwwroot/hubdocs.html
@@ -60,6 +60,19 @@
                     <h1 class="text-3xl font-bold text-white">HubDocs</h1>
                     <p class="text-gray-400 mt-1">SignalR Hubs Explorer</p>
                 </div>
+                    <section id="api-info" class="hidden mt-5 bg-[#202020] border border-[#3a3a3a] rounded-lg p-5">
+                        <div class="flex items-start justify-between gap-4 flex-wrap">
+                            <div>
+                                <div class="flex items-center gap-3 flex-wrap">
+                                    <h2 id="api-title" class="text-2xl font-semibold text-white"></h2>
+                                    <span id="api-version" class="text-xs uppercase tracking-wide bg-blue-900/50 border border-blue-700 text-blue-200 px-2 py-1 rounded"></span>
+                                </div>
+                                <p id="api-description" class="text-gray-300 mt-2"></p>
+                            </div>
+                        </div>
+
+                        <div id="api-links" class="mt-4 text-sm text-gray-300 space-y-1"></div>
+                    </section>
             </div>
             <div class="flex items-center gap-4">
                 <div class="text-sm text-gray-400">
@@ -90,6 +103,7 @@ <h1 class="text-3xl font-bold text-white">HubDocs</h1>
                 </a>
             </div>
         </div>
+
     </header>
 
     <div id="hubs" class="space-y-6"></div>
@@ -125,9 +139,55 @@ <h1 class="text-3xl font-bold text-white">HubDocs</h1>
 <script>
     const BASE_API_URL = "";
 
+        function esc(value) {
+            return String(value ?? "")
+                .replaceAll("&", "&amp;")
+                .replaceAll("<", "&lt;")
+                .replaceAll(">", "&gt;");
+        }
+
+        function renderApiInfo(doc) {
+            if (!doc || !doc.hubdocs) return;
+
+            const meta = doc.hubdocs;
+            const section = document.getElementById("api-info");
+            const title = document.getElementById("api-title");
+            const version = document.getElementById("api-version");
+            const description = document.getElementById("api-description");
+            const links = document.getElementById("api-links");
+
+            title.textContent = meta.title || "HubDocs";
+            version.textContent = meta.version || "v1";
+            description.textContent = meta.description || "";
+
+            const rows = [];
+            if (meta.projectUrl) rows.push(`Project: <a class="text-blue-400 hover:underline" target="_blank" href="${esc(meta.projectUrl)}">${esc(meta.projectUrl)}</a>`);
+            if (meta.termsOfService) rows.push(`Terms: <a class="text-blue-400 hover:underline" target="_blank" href="${esc(meta.termsOfService)}">${esc(meta.termsOfService)}</a>`);
+
+            if (meta.contact) {
+                const contactParts = [];
+                if (meta.contact.name) contactParts.push(esc(meta.contact.name));
+                if (meta.contact.email) contactParts.push(`<a class="text-blue-400 hover:underline" href="mailto:${esc(meta.contact.email)}">${esc(meta.contact.email)}</a>`);
+                if (meta.contact.url) contactParts.push(`<a class="text-blue-400 hover:underline" target="_blank" href="${esc(meta.contact.url)}">${esc(meta.contact.url)}</a>`);
+                if (contactParts.length > 0) rows.push(`Contact: ${contactParts.join(" · ")}`);
+            }
+
+            if (meta.license && (meta.license.name || meta.license.url)) {
+                const license = meta.license.url
+                    ? `<a class="text-blue-400 hover:underline" target="_blank" href="${esc(meta.license.url)}">${esc(meta.license.name || meta.license.url)}</a>`
+                    : esc(meta.license.name);
+                rows.push(`License: ${license}`);
+            }
+
+            links.innerHTML = rows.map((r) => `<div>${r}</div>`).join("");
+            section.classList.remove("hidden");
+        }
+
     fetch(`${BASE_API_URL}/hubdocs/hubdocs.json`)
         .then((res) => res.json())
-        .then((hubs) => {
+        .then((doc) => {
+                renderApiInfo(doc);
+            const hubs = Array.isArray(doc) ? doc : (doc.hubs || []);
             const container = document.getElementById("hubs");
             const hubCount = document.getElementById("hub-count");
 
diff --git a/tests/HubDocs.UnitTests/ExtensionsInternalTests.cs b/tests/HubDocs.UnitTests/ExtensionsInternalTests.cs
index 5d72c3a..da29d5a 100644
--- a/tests/HubDocs.UnitTests/ExtensionsInternalTests.cs
+++ b/tests/HubDocs.UnitTests/ExtensionsInternalTests.cs
@@ -91,6 +91,53 @@ public void DiscoverSignalRHubs_WhenStronglyTypedHubPresent_ShouldIncludeClientM
         Assert.DoesNotContain(discovered, h => h.HubName == nameof(NotRegisteredHub));
     }
 
+    [Fact]
+    public void BuildHubDocsDocument_WhenHubsAreProvided_ShouldProduceStructuredProtocolDocument()
+    {
+        // Arrange
+        var discoverMethod = typeof(Extensions).GetMethod(
+            "DiscoverSignalRHubs",
+            BindingFlags.NonPublic | BindingFlags.Static);
+
+        var hubDocsMethod = typeof(Extensions).GetMethod(
+            "BuildHubDocsDocument",
+            BindingFlags.NonPublic | BindingFlags.Static,
+            binder: null,
+            types: new[] { typeof(IReadOnlyList<HubMetadata>) },
+            modifiers: null);
+
+        Assert.NotNull(discoverMethod);
+        Assert.NotNull(hubDocsMethod);
+
+        var routes = new Dictionary<Type, string>
+        {
+            { typeof(TypedHub), "/hubs/typed" }
+        };
+
+        var hubs = Assert.IsAssignableFrom<IEnumerable<HubMetadata>>(
+            discoverMethod!.Invoke(null, new object[] { routes, new[] { typeof(TypedHub).Assembly } }))
+            .ToList();
+
+        // Act
+        var document = Assert.IsAssignableFrom<Dictionary<string, object?>>(
+            hubDocsMethod!.Invoke(null, new object[] { hubs }));
+
+        // Assert
+        var hubdocs = Assert.IsAssignableFrom<Dictionary<string, object?>>(document["hubdocs"]);
+        Assert.Equal("hubdocs-1.0", Assert.IsType<string>(hubdocs["format"]));
+        Assert.Equal("1.0.0", Assert.IsType<string>(hubdocs["version"]));
+
+        var exportedHubs = Assert.IsAssignableFrom<IEnumerable<HubMetadata>>(document["hubs"]);
+        Assert.NotEmpty(exportedHubs);
+
+        var channels = Assert.IsAssignableFrom<Dictionary<string, object?>>(document["channels"]);
+        Assert.Contains("/hubs/typed", channels.Keys);
+
+        var components = Assert.IsAssignableFrom<Dictionary<string, object?>>(document["components"]);
+        Assert.True(components.ContainsKey("messages"));
+        Assert.True(components.ContainsKey("schemas"));
+    }
+
     [Fact]
     public void GetMethodSignature_WhenMethodHasParameters_ShouldIncludeParameterTypeNames()
     {