{"id":5289,"date":"2026-10-19T16:12:04","date_gmt":"2026-10-19T16:12:04","guid":{"rendered":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/10\/19\/bring-your-own-model-to-the-github-copilot-sdk-with-c\/"},"modified":"2026-10-19T16:12:04","modified_gmt":"2026-10-19T16:12:04","slug":"bring-your-own-model-to-the-github-copilot-sdk-with-c","status":"publish","type":"post","link":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/2026\/10\/19\/bring-your-own-model-to-the-github-copilot-sdk-with-c\/","title":{"rendered":"Bring Your Own Model to the GitHub Copilot SDK with C#"},"content":{"rendered":"<p>Hi,<\/p>\n<p>I know, I keep coming back to the same theme on this blog: <strong>agent harnesses<\/strong>. In <a href=\"https:\/\/devblogs.microsoft.com\/dotnet\/build-your-own-ai-agent-harness-in-csharp-the-maf-claw-live-series\/\">Build Your Own AI Agent Harness in C#<\/a> we built one from scratch. In <a href=\"https:\/\/devblogs.microsoft.com\/dotnet\/from-dotnet-run-to-foundry-hosted-agent-in-3-lines-of-csharp\/\">From dotnet run to Foundry Hosted Agent in 3 lines of C#<\/a> we took an agent and hosted it. Today we use a harness we do not have to build at all: the one GitHub already ships, through the <strong>GitHub Copilot SDK<\/strong>.<\/p>\n<p>One of the most popular questions we received during the <strong>Let\u2019s Learn GitHub Copilot SDK<\/strong> sessions was:<\/p>\n<blockquote>\n<p>\u201cCan I use the Copilot SDK with my own model deployment?\u201d<\/p>\n<\/blockquote>\n<p>The short answer is <strong>yes<\/strong>.<\/p>\n<p>The longer answer is, the GitHub Copilot SDK gives your application the Copilot agent runtime, while <code>ProviderConfig<\/code> lets you route model inference to a provider you control. That provider can be any of the <a href=\"https:\/\/docs.github.com\/en\/copilot\/how-tos\/copilot-sdk\/auth\/byok\">providers officially supported by the Copilot SDK<\/a>: OpenAI, Anthropic, Ollama, Microsoft Foundry Local, or any OpenAI-compatible endpoint such as vLLM or LiteLLM. Today\u2019s sample uses <strong>Microsoft Foundry<\/strong>, authenticated with Microsoft Entra ID or, when needed, an API key.<\/p>\n<p>The complete sample is now part of <a href=\"https:\/\/github.com\/microsoft\/Generative-AI-for-beginners-dotnet\/tree\/main\/samples\/CoreSamples\/GitHubCopilotSDK-01-BYOK\">Generative AI for Beginners .NET<\/a>. It is a small .NET 10 console application: read configuration, create a BYOK provider, start the Copilot runtime, create one session, and ask one question.<\/p>\n\n<div class=\"d-flex justify-content-center\"><a class=\"cta_button_link btn-primary mb-24\" href=\"https:\/\/github.com\/microsoft\/Generative-AI-for-beginners-dotnet\/tree\/main\/samples\/CoreSamples\/GitHubCopilotSDK-01-BYOK\" target=\"_blank\">Get the complete BYOK C# sample<\/a><\/div>\n<h2>What BYOK means in this sample<\/h2>\n<p>BYOK means <strong>Bring Your Own Key<\/strong>, but in this context the important idea is broader than the key itself: you bring your own model provider.<\/p>\n<p>The Copilot SDK still supplies the runtime that manages the client, session, system message, and agent configuration. <code>ProviderConfig<\/code> changes the destination and authentication for model inference.<\/p>\n\n<div class=\"alert alert-success\">\n<p class=\"alert-divider\"><i class=\"fabric-icon fabric-icon--Lightbulb\"><\/i><strong>BYOK is not customer-managed encryption keys<\/strong><\/p>\n<p>In this article, BYOK means using your own model endpoint and credentials for inference. It does not refer to customer-managed encryption keys or a storage-encryption configuration.<\/p><\/div>\n<p>The sample intentionally keeps the session minimal. It disables tools, skills, configuration discovery, and host Git operations so that the first run demonstrates one thing clearly: a Copilot SDK session can send a model request to your own Foundry-compatible deployment.<\/p>\n<p><img data-opt-id=1567496026  fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/devblogs.microsoft.com\/dotnet\/bring-your-own-model-to-the-github-copilot-sdk-with-csharp\/github-copilot-sdk-byok-diagram.svg\" alt=\"Diagram of a .NET app routing Copilot SDK requests to Microsoft Foundry\" \/><\/p>\n<p><em>The runtime and the model provider are separate parts of the application.<\/em><\/p>\n<h2>The project<\/h2>\n<p>The sample is a regular .NET 10 console application. These are the packages it uses:<\/p>\n<pre><code class=\"language-xml\">&lt;Project Sdk=\"Microsoft.NET.Sdk\"&gt;\n  &lt;PropertyGroup&gt;\n    &lt;OutputType&gt;Exe&lt;\/OutputType&gt;\n    &lt;TargetFramework&gt;net10.0&lt;\/TargetFramework&gt;\n    &lt;ImplicitUsings&gt;enable&lt;\/ImplicitUsings&gt;\n    &lt;Nullable&gt;enable&lt;\/Nullable&gt;\n    &lt;UserSecretsId&gt;genai-beginners-dotnet&lt;\/UserSecretsId&gt;\n  &lt;\/PropertyGroup&gt;\n\n  &lt;ItemGroup&gt;\n    &lt;PackageReference Include=\"Azure.Identity\" Version=\"1.21.0\" \/&gt;\n    &lt;PackageReference Include=\"GitHub.Copilot.SDK\" Version=\"1.0.11\" \/&gt;\n    &lt;PackageReference Include=\"Microsoft.Extensions.Configuration\" Version=\"10.0.3\" \/&gt;\n    &lt;PackageReference Include=\"Microsoft.Extensions.Configuration.UserSecrets\" Version=\"10.0.3\" \/&gt;\n  &lt;\/ItemGroup&gt;\n&lt;\/Project&gt;<\/code><\/pre>\n<p><code>GitHub.Copilot.SDK<\/code> provides the .NET client for the Copilot runtime. <code>Azure.Identity<\/code> provides <code>AzureCliCredential<\/code>, which lets the sample reuse the identity from <code>az login<\/code>. The configuration packages load development-only secrets without putting endpoints or credentials in source control.<\/p>\n<h2>Step 1: read the model configuration<\/h2>\n<p>The sample uses the shared User Secrets values already used by the repository:<\/p>\n<pre><code class=\"language-csharp\">\/\/ User Secrets keeps the endpoint and credentials outside the repository.\nvar configuration = new ConfigurationBuilder()\n    .AddUserSecrets&lt;Program&gt;(optional: true)\n    .Build();\n\n\/\/ This sample uses the repo's shared AzureOpenAI secrets.\nvar modelName = GetRequiredValue(configuration, \"AzureOpenAI:Deployment\");\nvar endpoint = GetRequiredValue(configuration, \"AzureOpenAI:Endpoint\");\nvar apiKey = configuration[\"AzureOpenAI:ApiKey\"]?.Trim();<\/code><\/pre>\n<p>There are two required values:<\/p>\n<ul>\n<li><code>AzureOpenAI:Deployment<\/code> is the name of your model deployment in Microsoft Foundry or Azure OpenAI. Choose a deployment that supports the Responses API, because this sample uses <code>WireApi = \"responses\"<\/code>.<\/li>\n<li><code>AzureOpenAI:Endpoint<\/code> is the Foundry or Azure OpenAI resource endpoint.<\/li>\n<\/ul>\n<p><code>AzureOpenAI:ApiKey<\/code> is optional. If it is not present, the sample uses Microsoft Entra ID through <code>AzureCliCredential<\/code>. If it is present, the sample sends it in the <code>api-key<\/code> header.<\/p>\n<h2>Step 2: configure the provider<\/h2>\n<p>This is the core of the sample:<\/p>\n<pre><code class=\"language-csharp\">\/\/ Microsoft Foundry exposes an API compatible with OpenAI Responses.\nvar provider = new ProviderConfig\n{\n    Type = \"openai\",\n    BaseUrl = NormalizeEndpoint(endpoint),\n    WireApi = \"responses\",\n    ModelId = modelName,\n    WireModel = modelName,\n    MaxPromptTokens = 8000,\n    MaxOutputTokens = 512\n};<\/code><\/pre>\n<p>The configuration tells the Copilot runtime how to communicate with the provider:<\/p>\n<ul>\n<li><code>Type = \"openai\"<\/code> selects the OpenAI-compatible provider shape.<\/li>\n<li><code>BaseUrl<\/code> points to the OpenAI-compatible API surface.<\/li>\n<li><code>WireApi = \"responses\"<\/code> selects the Responses API.<\/li>\n<li><code>ModelId<\/code> identifies the model to the Copilot runtime.<\/li>\n<li><code>WireModel<\/code> is the model name sent to the provider.<\/li>\n<li>The token limits keep this small example bounded.<\/li>\n<\/ul>\n<p>For a reasoning model, <code>MaxOutputTokens<\/code> includes reasoning tokens as well as the visible answer. The 512-token limit can be reached before the model produces any answer. Increase or omit the <code>MaxOutputTokens<\/code> override when using a reasoning deployment, then tune the limit for your workload.<\/p>\n<p>In this sample, <code>ModelId<\/code> and <code>WireModel<\/code> have the same value. They are separate properties because the runtime-facing model identifier and the provider-facing model name do not have to be identical in every integration.<\/p>\n<p>The endpoint helper accepts either the resource URL or a URL that already includes <code>\/openai\/v1\/<\/code>:<\/p>\n<pre><code class=\"language-csharp\">static string NormalizeEndpoint(string endpoint)\n{\n    var candidate = endpoint.Trim();\n    if (!Uri.TryCreate(candidate, UriKind.Absolute, out var uri) ||\n        uri.Scheme != Uri.UriSchemeHttps ||\n        string.IsNullOrWhiteSpace(uri.Host))\n    {\n        throw new ArgumentException(\"The configured AzureOpenAI:Endpoint must be an HTTPS URL.\");\n    }\n\n    \/\/ Accept the resource URL or a URL that already ends in \/openai\/v1.\n    \/\/ Trimming first means a trailing slash does not need a separate check.\n    var trimmed = candidate.TrimEnd('\/');\n    if (trimmed.EndsWith(\"\/openai\/v1\", StringComparison.OrdinalIgnoreCase))\n    {\n        return trimmed + \"\/\";\n    }\n\n    return $\"{uri.GetLeftPart(UriPartial.Authority).TrimEnd('\/')}\/openai\/v1\/\";\n}<\/code><\/pre>\n<p>The helper also requires HTTPS. It is better to reject a malformed endpoint before creating a session than to discover it after the first model request.<\/p>\n<h2>Step 3: use Entra ID by default<\/h2>\n<p>The default authentication path uses the Azure CLI login:<\/p>\n<pre><code class=\"language-csharp\">if (string.IsNullOrWhiteSpace(apiKey))\n{\n    \/\/ AzureCliCredential reuses the session created with `az login`.\n    var credential = new AzureCliCredential();\n    var scope = \"https:\/\/cognitiveservices.azure.com\/.default\";\n#pragma warning disable GHCP001 \/\/ BYOK auth callbacks are experimental in the Copilot SDK.\n    provider.BearerTokenProvider = async _ =&gt;\n    {\n        var token = await credential.GetTokenAsync(\n            new TokenRequestContext([scope]),\n            cancellation.Token);\n        return token.Token;\n    };\n#pragma warning restore GHCP001\n}<\/code><\/pre>\n<p>Before signing in, make sure your identity has the <strong>Cognitive Services OpenAI User<\/strong> role on the resource. Then run:<\/p>\n<pre><code class=\"language-powershell\">az login<\/code><\/pre>\n<p><code>BearerTokenProvider<\/code> is a callback. The SDK can call it when it needs a token instead of receiving one token value that the application has to manage itself.<\/p>\n<h2>Step 4: use an API key when one is configured<\/h2>\n<p>Some deployments or environments still require an API key. The sample supports that path without changing the rest of the provider configuration:<\/p>\n<pre><code class=\"language-csharp\">else\n{\n    provider.Headers = new Dictionary&lt;string, string&gt;\n    {\n        [\"api-key\"] = apiKey\n    };\n}<\/code><\/pre>\n<p>Set the optional secret:<\/p>\n<pre><code class=\"language-powershell\">dotnet user-secrets set \"AzureOpenAI:ApiKey\" \"&lt;your-api-key&gt;\"<\/code><\/pre>\n<p>When the value exists, the sample uses the <code>api-key<\/code> header and does not require <code>az login<\/code>. The console output reports only the authentication mode; it never prints the endpoint or the credential.<\/p>\n\n<div class=\"alert alert-info\">\n<p class=\"alert-divider\"><i class=\"fabric-icon fabric-icon--Info\"><\/i><strong>Keep credentials out of source control<\/strong><\/p>\n<p>Use User Secrets for local development, environment-managed configuration for deployed applications, and never paste an API key into the source file or a README.<\/p><\/div>\n<h2>Step 5: start the Copilot runtime<\/h2>\n<p>The provider controls model inference, but the Copilot runtime is still required:<\/p>\n<pre><code class=\"language-csharp\">await using var client = new CopilotClient(new CopilotClientOptions\n{\n    Connection = RuntimeConnection.ForStdio(\"copilot\"),\n    WorkingDirectory = AppContext.BaseDirectory\n});\nawait client.StartAsync(cancellation.Token);<\/code><\/pre>\n<p>This is an important distinction. BYOK does not mean \u201cthe Copilot SDK without Copilot.\u201d The local Copilot CLI runtime still provides the orchestration process. BYOK changes where the model request goes.<\/p>\n\n<div class=\"alert alert-primary\">\n<p class=\"alert-divider\"><i class=\"fabric-icon fabric-icon--Info\"><\/i><strong>Prerequisites<\/strong><\/p>\n<p>Install the .NET 10 SDK and the GitHub Copilot CLI, and make sure <code>dotnet --version<\/code> reports a .NET 10 SDK and <code>copilot --version<\/code> works. For the default Microsoft Entra ID authentication path, also install the Azure CLI and make sure <code>az --version<\/code> works. The API-key path does not require the Azure CLI. The sample starts the local Copilot runtime through <code>RuntimeConnection.ForStdio(\"copilot\")<\/code>.<\/p><\/div>\n<h2>Step 6: create a deliberately small session<\/h2>\n<p>The session configuration connects the model name and provider, then disables capabilities that are outside the scope of this first example:<\/p>\n<pre><code class=\"language-csharp\">\/\/ Disable tools, skills, and Git operations to isolate the model request.\nawait using var session = await client.CreateSessionAsync(new SessionConfig\n{\n    ClientName = \"github-copilot-sdk-byok\",\n    Model = modelName,\n    Provider = provider,\n    SystemMessage = new SystemMessageConfig\n    {\n        Mode = SystemMessageMode.Replace,\n        Content = \"Answer every user question in English. Be concise and factual.\"\n    },\n    AvailableTools = [],\n    Tools = [],\n    EnableConfigDiscovery = false,\n    EnableSkills = false,\n    EnableHostGitOperations = false\n}, cancellation.Token);<\/code><\/pre>\n<p>The empty tool collections and disabled features are intentional. They make the sample easier to reason about and safer to run while learning the provider configuration.<\/p>\n<p>The system message also makes the output predictable for a multilingual live-learning sample. <code>SystemMessageMode.Replace<\/code> replaces the default system message instead of appending another instruction to it.<\/p>\n<h2>Step 7: send one question<\/h2>\n<p>Finally, the application sends one prompt and waits for the final response:<\/p>\n<pre><code class=\"language-csharp\">var response = await session.SendAndWaitAsync(\n    new MessageOptions { Prompt = question },\n    TimeSpan.FromMinutes(3),\n    cancellation.Token);\n\nvar content = response?.Data.Content;\nif (string.IsNullOrWhiteSpace(content))\n{\n    throw new InvalidOperationException(\"The model returned an empty response.\");\n}\n\nConsole.WriteLine();\nConsole.WriteLine(\"Answer:\");\nConsole.WriteLine(content);<\/code><\/pre>\n<p>The default question is:<\/p>\n<pre><code class=\"language-text\">What is Microsoft Foundry, and how does it relate to the GitHub Copilot SDK?<\/code><\/pre>\n<p>You can provide another question as command-line arguments:<\/p>\n<pre><code class=\"language-powershell\">dotnet run -- \"Explain BYOK in one sentence.\"<\/code><\/pre>\n<h2>Run the sample<\/h2>\n<p>From the sample directory, configure the required values:<\/p>\n<pre><code class=\"language-powershell\">dotnet user-secrets set \"AzureOpenAI:Endpoint\" \"https:\/\/&lt;resource&gt;.services.ai.azure.com\"\ndotnet user-secrets set \"AzureOpenAI:Deployment\" \"&lt;your-deployment-name&gt;\"<\/code><\/pre>\n<p>Then use the default Entra ID path:<\/p>\n<pre><code class=\"language-powershell\">az login\ndotnet run<\/code><\/pre>\n<p>The output looks like this:<\/p>\n<pre><code class=\"language-text\">Model: &lt;your-deployment-name&gt;\nAuthentication: AzureCliCredential\nQuestion: What is Microsoft Foundry, and how does it relate to the GitHub Copilot SDK?\n\nAnswer:\n&lt;model response&gt;<\/code><\/pre>\n<p>The sample prints the selected model and authentication mode, but not the endpoint or credentials.<\/p>\n<h2>So, what did we actually learn here?<\/h2>\n<p>Honestly, the part I like most is how little code this takes. <img data-opt-id=1710049426  fetchpriority=\"high\" decoding=\"async\" src=\"https:\/\/s.w.org\/images\/core\/emoji\/17.0.2\/72x72\/1f642.png\" alt=\"\ud83d\ude42\" class=\"wp-smiley\" \/><\/p>\n<p>The Copilot SDK runtime and the model provider are two different things, and once that clicks, the rest is easy. You keep the runtime that GitHub gives you: the client, the session, the system message, and the agent plumbing. Then you just point inference somewhere else. That \u201csomewhere else\u201d is your Foundry deployment, your OpenAI key, your local Ollama, whatever you need.<\/p>\n<p>Entra ID is the default path here, and I think it should be. No key to rotate, no key to leak, no key to accidentally commit. <code>az login<\/code> and you are done. The API key branch is there for the cases where you really need it, and it stays out of the way until you configure it.<\/p>\n<p>And the session is deliberately boring. No tools, no skills, no MCP, no Git access. That is on purpose: the first run has exactly one job, which is proving that your model is answering. Once you see that answer in the console, you have a working baseline.<\/p>\n<p>That is the fun part. From here you can start adding things one at a time: tools, MCP servers, skills, approvals, and streaming. When something breaks, you will know exactly which piece broke it.<\/p>\n<p>Go try it with your own deployment. <img data-opt-id=1609354503  data-opt-src=\"https:\/\/s.w.org\/images\/core\/emoji\/17.0.2\/72x72\/1f680.png\"  decoding=\"async\" src=\"data:image/svg+xml,%3Csvg%20viewBox%3D%220%200%20100%%20100%%22%20width%3D%22100%%22%20height%3D%22100%%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Crect%20width%3D%22100%%22%20height%3D%22100%%22%20fill%3D%22transparent%22%2F%3E%3C%2Fsvg%3E\" alt=\"\ud83d\ude80\" class=\"wp-smiley\" \/><\/p>\n<h2>Learn more<\/h2>\n<ul>\n<li><a href=\"https:\/\/github.com\/microsoft\/Generative-AI-for-beginners-dotnet\/tree\/main\/samples\/CoreSamples\/GitHubCopilotSDK-01-BYOK\">GitHubCopilotSDK-01-BYOK sample<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/microsoft\/Generative-AI-for-beginners-dotnet\">Generative AI for Beginners .NET<\/a><\/li>\n<li><a href=\"https:\/\/github.com\/github\/copilot-sdk\">GitHub Copilot SDK<\/a><\/li>\n<li><a href=\"https:\/\/aka.ms\/letslearndotnet\">Let\u2019s Learn .NET<\/a><\/li>\n<li><a href=\"https:\/\/dotnet.microsoft.com\/live\/lets-learn-dotnet\">Let\u2019s Learn .NET event page<\/a><\/li>\n<li><a href=\"https:\/\/gh.io\/coursera\">Building Agentic AI Apps with GitHub Copilot SDK (Coursera Professional Certificate)<\/a><\/li>\n<li><a href=\"https:\/\/ai.azure.com\/\">Microsoft Foundry<\/a><\/li>\n<\/ul>\n<div class=\"d-flex justify-content-center\"><a class=\"cta_button_link btn-primary mb-24\" href=\"https:\/\/github.com\/microsoft\/Generative-AI-for-beginners-dotnet\/tree\/main\/samples\/CoreSamples\/GitHubCopilotSDK-01-BYOK\" target=\"_blank\">Explore the complete GitHub Copilot SDK sample<\/a><\/div>\n<p>Happy coding!<\/p>\n<p>Bruno<\/p>\n<p>The post <a href=\"https:\/\/devblogs.microsoft.com\/dotnet\/bring-your-own-model-to-the-github-copilot-sdk-with-csharp\/\">Bring Your Own Model to the GitHub Copilot SDK with C#<\/a> appeared first on <a href=\"https:\/\/devblogs.microsoft.com\/dotnet\">.NET Blog<\/a>.<\/p>","protected":false},"excerpt":{"rendered":"<p>Hi, I know, I keep coming back to the same theme on this blog: agent harnesses. In Build Your Own [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":94,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[7],"tags":[],"class_list":["post-5289","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet"],"_links":{"self":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/5289","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/comments?post=5289"}],"version-history":[{"count":0,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/posts\/5289\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media\/94"}],"wp:attachment":[{"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/media?parent=5289"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/categories?post=5289"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/rssfeedtelegrambot.bnaya.co.il\/index.php\/wp-json\/wp\/v2\/tags?post=5289"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}