Using CodeCompanion with Anthropic signed-in account (Like Claude Code)

[andtankian]

This isn’t the most conventional approach — but it works.

Antropic.Logged.mp4

Claude Code lets you use an Anthropic Pro subscription account and call Claude models without being charged for wasted API tokens. Of course, there’s a daily quota, but in my experience it’s surprisingly generous — I was able to work the entire day without hitting the limit. That’s incredible, considering how expensive Anthropic tokens normally are.

To figure out how Claude Code manages this, I read through some docs and ran a man-in-the-middle proxy to capture the requests and responses being sent to Anthropic’s API. Here’s what I found:

1. It uses the same endpoint as API key users.
2. A couple of headers are different when the request comes from Claude Code.
3. Authentication is done using OAuth — it sends a bearer token in the Authorization header.
4. A required system message is prepended to every prompt.

⚠️ Important: The current custom adapter does not perform the OAuth flow. It simply injects an already-logged-in bearer token into the request.

---

How do you get a valid signed-in token?

On macOS:
Open the Keychain Access app and search for “Claude Code”. View the entry to reveal the token, then export it to an environment variable:

export ANTHROPIC_BEARER_TOKEN=xxxx

On other systems:
Use a tool like mitmproxy to intercept Claude Code’s traffic, then capture and copy the bearer token from one of the API calls.

---

I’ve now built a simple custom adapter that lets our CodeCompanion plugin use Anthropic as if we were logged in through Claude Code — without needing a direct API key:

(Paste this in y

---@param params table Table containing message and allowed_words
---@return table The filtered message
local function filter_out_messages(params)
	local message = params.message

	local allowed = params.allowed_words

	for key, _ in pairs(message) do
		if not vim.tbl_contains(allowed, key) then
			message[key] = nil
		end
	end
	return message
end

-- 👆 local function before the CodeCompanion configuration

-- CodeCompanion Setup ...

-- 👇🏼 paste this inside the adapters options

{
	adapters = {
		anthropic_with_bearer_token = function()
	local utils = require("codecompanion.utils.adapters")
	local tokens = require("codecompanion.utils.tokens")

	return require("codecompanion.adapters").extend("anthropic", {
		env = {
			bearer_token = "ANTHROPIC_BEARER_TOKEN",
		},
		headers = {
			["content-type"] = "application/json",
			["authorization"] = "Bearer ${bearer_token}",
			["anthropic-version"] = "2023-06-01",
			["anthropic-beta"] = "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
		},
		handlers = {
			setup = function(self)
				-- Same as current setup function but removing the additional headers being added

				if self.opts and self.opts.stream then
					self.parameters.stream = true
				end

				local model = self.schema.model.default
				local model_opts = self.schema.model.choices[model]
				if model_opts and model_opts.opts then
					self.opts = vim.tbl_deep_extend("force", self.opts, model_opts.opts)
					if not model_opts.opts.has_vision then
						self.opts.vision = false
					end
				end

				return true
			end,

			form_messages = function(self, messages)
				-- Same as current form_message but adding Claude Code system message at the first system message

				local has_tools = false

				local system = vim
					.iter(messages)
					:filter(function(msg)
						return msg.role == "system"
					end)
					:map(function(msg)
						return {
							type = "text",
							text = msg.content,
							cache_control = nil,
						}
					end)
					:totable()

				-- Add the Claude Code system message at the beginning (required to make it work)
				table.insert(system, 1, {
					type = "text",
					text = "You are Claude Code, Anthropic's official CLI for Claude.",
					cache_control = {
						type = "ephemeral",
					},
				})

				system = next(system) and system or nil

				messages = vim
					.iter(messages)
					:filter(function(msg)
						return msg.role ~= "system"
					end)
					:totable()

				messages = vim.tbl_map(function(message)
					if message.opts and message.opts.tag == "image" and message.opts.mimetype then
						if self.opts and self.opts.vision then
							message.content = {
								{
									type = "image",
									source = {
										type = "base64",
										media_type = message.opts.mimetype,
										data = message.content,
									},
								},
							}
						else
							return nil
						end
					end

					message = filter_out_messages({
						message = message,
						allowed_words = { "content", "role", "reasoning", "tool_calls" },
					})

					if message.role == self.roles.user or message.role == self.roles.llm then
						if message.role == self.roles.user and message.content == "" then
							message.content = "<prompt></prompt>"
						end

						if type(message.content) == "string" then
							message.content = {
								{ type = "text", text = message.content },
							}
						end
					end

					if message.tool_calls and vim.tbl_count(message.tool_calls) > 0 then
						has_tools = true
					end

					if message.role == "tool" then
						message.role = self.roles.user
					end

					if has_tools and message.role == self.roles.llm and message.tool_calls then
						message.content = message.content or {}
						for _, call in ipairs(message.tool_calls) do
							table.insert(message.content, {
								type = "tool_use",
								id = call.id,
								name = call["function"].name,
								input = vim.json.decode(call["function"].arguments),
							})
						end
						message.tool_calls = nil
					end

					if message.reasoning and type(message.content) == "table" then
						table.insert(message.content, 1, {
							type = "thinking",
							thinking = message.reasoning.content,
							signature = message.reasoning._data.signature,
						})
					end

					return message
				end, messages)

				messages = utils.merge_messages(messages)

				if has_tools then
					for _, m in ipairs(messages) do
						if m.role == self.roles.user and m.content and m.content ~= "" then
							if type(m.content) == "table" and m.content.type then
								m.content = { m.content }
							end

							if type(m.content) == "table" and vim.islist(m.content) then
								local consolidated = {}
								for _, block in ipairs(m.content) do
									if block.type == "tool_result" then
										local prev = consolidated[#consolidated]
										if prev and prev.type == "tool_result" and prev.tool_use_id == block.tool_use_id then
											prev.content = prev.content .. block.content
										else
											table.insert(consolidated, block)
										end
									else
										table.insert(consolidated, block)
									end
								end
								m.content = consolidated
							end
						end
					end
				end

				local breakpoints_used = 0
				for i = #messages, 1, -1 do
					local msgs = messages[i]
					if msgs.role == self.roles.user then
						for _, msg in ipairs(msgs.content) do
							if msg.type ~= "text" or msg.text == "" then
								goto continue
							end
							if
								tokens.calculate(msg.text) >= self.opts.cache_over
								and breakpoints_used < self.opts.cache_breakpoints
							then
								msg.cache_control = { type = "ephemeral" }
								breakpoints_used = breakpoints_used + 1
							end
							::continue::
						end
					end
				end
				if system and breakpoints_used < self.opts.cache_breakpoints then
					for _, prompt in ipairs(system) do
						if breakpoints_used < self.opts.cache_breakpoints then
							prompt.cache_control = { type = "ephemeral" }
							breakpoints_used = breakpoints_used + 1
						end
					end
				end

				return { system = system, messages = messages }
			end,
		},
	})
end,
	},
}

It will be awesome if someone get this adapter as inspiration to make the OAuth authentication as well.

[jinzhongjia]

Oh my god, man, you're amazing

[jinzhongjia]

I tried to create an adapter with oauth flow, now the oauth flow has passed, but when requesting, the token will report the lack of scope. I also encountered this problem in opencode.

https://github.com/jinzhongjia/codecompanion.nvim/tree/anthropic_oauth

[jinzhongjia]

If there is no additional consumption using claude code, then using this theory will not

Login authentication and key creation logic is the same as claude code

[jinzhongjia]

I can't reproduce your problem at the moment

[cenk1cenk2]

Ah, I see. Thank you for your time and help, @jinzhongjia. I appreciate it very much.

[jinzhongjia]

Actually, I copied the current logic from opencode, and the opencode should be the result of reverse packet capture.

[cenk1cenk2]

Yes you are right, I tried this on another computer and works a charm. I will just try to cleanup cookies from the other computers to make it work there.

[connor11son]

Should I copy the whole sk-ant-oa101-xxx into the bearer_token env variable? I am getting this error when trying to use this adapter:

[chat::init::_submit_http] Error: {
  body = '{"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"},"request_id":"req_011CSkR57EsZuDjaKXXYboC3"}',
  exit = 0,
  headers = { "date: Tue, 02 Sep 2025 23:08:38 GMT", "content-type: application/json", "content-length: 130", "cf-ray: 9790aba3cacecb9f-LAX", "x-should-retry: false", "request-id: req_011CSkR57EsZuDjaKXXYboC3", "strict-transport-security: max-age=31536000; includeSubDomains; preload",
 "x-envoy-upstream-service-time: 6", "via: 1.1 google", "cf-cache-status: DYNAMIC", "x-robots-tag: none", "server: cloudflare" },
  status = 401

[andtankian]

Can you share your config so I can take a look at it? 🤔

[connor11son]

I really appreciate the help

-- Helper function for filtering messages (place this before the plugin configuration)
---@param params table Table containing message and allowed_words
---@return table The filtered message
local function filter_out_messages(params)
  local message = params.message
  local allowed = params.allowed_words

  for key, _ in pairs(message) do
    if not vim.tbl_contains(allowed, key) then
      message[key] = nil
    end
  end
  return message
end

-- Plugin configuration
return {
  {
    'olimorris/codecompanion.nvim',
    dependencies = {
      'nvim-lua/plenary.nvim',
      'nvim-treesitter/nvim-treesitter',
    },
    opts = {
      adapters = {
        anthropic_with_bearer_token = function()
          local utils = require 'codecompanion.utils.adapters'
          local tokens = require 'codecompanion.utils.tokens'

          return require('codecompanion.adapters').extend('anthropic', {
            env = {
              bearer_token = 'ANTHROPIC_BEARER_TOKEN',
            },
            headers = {
              ['content-type'] = 'application/json',
              ['authorization'] = 'Bearer ${bearer_token}',
              ['anthropic-version'] = '2023-06-01',
              ['anthropic-beta'] = 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14',
            },
            handlers = {
              setup = function(self)
                -- Same as current setup function but removing the additional headers being added
                if self.opts and self.opts.stream then
                  self.parameters.stream = true
                end

                local model = self.schema.model.default
                local model_opts = self.schema.model.choices[model]
                if model_opts and model_opts.opts then
                  self.opts = vim.tbl_deep_extend('force', self.opts, model_opts.opts)
                  if not model_opts.opts.has_vision then
                    self.opts.vision = false
                  end
                end

                return true
              end,

              form_messages = function(self, messages)
                -- Same as current form_message but adding Claude Code system message at the first system message
                local has_tools = false

                local system = vim
                  .iter(messages)
                  :filter(function(msg)
                    return msg.role == 'system'
                  end)
                  :map(function(msg)
                    return {
                      type = 'text',
                      text = msg.content,
                      cache_control = nil,
                    }
                  end)
                  :totable()

                -- Add the Claude Code system message at the beginning (required to make it work)
                table.insert(system, 1, {
                  type = 'text',
                  text = "You are Claude Code, Anthropic's official CLI for Claude.",
                  cache_control = {
                    type = 'ephemeral',
                  },
                })

                system = next(system) and system or nil

                messages = vim
                  .iter(messages)
                  :filter(function(msg)
                    return msg.role ~= 'system'
                  end)
                  :totable()

                messages = vim.tbl_map(function(message)
                  if message.opts and message.opts.tag == 'image' and message.opts.mimetype then
                    if self.opts and self.opts.vision then
                      message.content = {
                        {
                          type = 'image',
                          source = {
                            type = 'base64',
                            media_type = message.opts.mimetype,
                            data = message.content,
                          },
                        },
                      }
                    else
                      return nil
                    end
                  end

                  message = filter_out_messages {
                    message = message,
                    allowed_words = { 'content', 'role', 'reasoning', 'tool_calls' },
                  }

                  if message.role == self.roles.user or message.role == self.roles.llm then
                    if message.role == self.roles.user and message.content == '' then
                      message.content = '<prompt></prompt>'
                    end

                    if type(message.content) == 'string' then
                      message.content = {
                        { type = 'text', text = message.content },
                      }
                    end
                  end

                  if message.tool_calls and vim.tbl_count(message.tool_calls) > 0 then
                    has_tools = true
                  end

                  if message.role == 'tool' then
                    message.role = self.roles.user
                  end

                  if has_tools and message.role == self.roles.llm and message.tool_calls then
                    message.content = message.content or {}
                    for _, call in ipairs(message.tool_calls) do
                      table.insert(message.content, {
                        type = 'tool_use',
                        id = call.id,
                        name = call['function'].name,
                        input = vim.json.decode(call['function'].arguments),
                      })
                    end
                    message.tool_calls = nil
                  end

                  if message.reasoning and type(message.content) == 'table' then
                    table.insert(message.content, 1, {
                      type = 'thinking',
                      thinking = message.reasoning.content,
                      signature = message.reasoning._data.signature,
                    })
                  end

                  return message
                end, messages)

                messages = utils.merge_messages(messages)

                if has_tools then
                  for _, m in ipairs(messages) do
                    if m.role == self.roles.user and m.content and m.content ~= '' then
                      if type(m.content) == 'table' and m.content.type then
                        m.content = { m.content }
                      end

                      if type(m.content) == 'table' and vim.islist(m.content) then
                        local consolidated = {}
                        for _, block in ipairs(m.content) do
                          if block.type == 'tool_result' then
                            local prev = consolidated[#consolidated]
                            if prev and prev.type == 'tool_result' and prev.tool_use_id == block.tool_use_id then
                              prev.content = prev.content .. block.content
                            else
                              table.insert(consolidated, block)
                            end
                          else
                            table.insert(consolidated, block)
                          end
                        end
                        m.content = consolidated
                      end
                    end
                  end
                end

                local breakpoints_used = 0
                for i = #messages, 1, -1 do
                  local msgs = messages[i]
                  if msgs.role == self.roles.user then
                    for _, msg in ipairs(msgs.content) do
                      if msg.type ~= 'text' or msg.text == '' then
                        goto continue
                      end
                      if tokens.calculate(msg.text) >= self.opts.cache_over and breakpoints_used < self.opts.cache_breakpoints then
                        msg.cache_control = { type = 'ephemeral' }
                        breakpoints_used = breakpoints_used + 1
                      end
                      ::continue::
                    end
                  end
                end
                if system and breakpoints_used < self.opts.cache_breakpoints then
                  for _, prompt in ipairs(system) do
                    if breakpoints_used < self.opts.cache_breakpoints then
                      prompt.cache_control = { type = 'ephemeral' }
                      breakpoints_used = breakpoints_used + 1
                    end
                  end
                end

                return { system = system, messages = messages }
              end,
            },
          })
        end,
      },
    },
  },
}

[andtankian]

@connor11son

I copied your configuration entirely and it worked here. Is your CodeCompanion updated? Based on the error it seems that it's using somehow the x-api-key header instead of bearer token. Is your anthropic subscription active in the pro plan?

[connor11son]

Yup it is active and I can use Claude Code perfectly fine from the CLI (I use mitmproxy to catch the token). Here's the current status of my codecompanion according to Lazy:

● codecompanion.nvim 21.7ms 🚀 start
dir /home/connor/.local/share/nvim/lazy/codecompanion.nvim
url https://github.com/olimorris/codecompanion.nvim
branch main
commit 7eb2f67
readme README.md
help |codecompanion.txt|

  📌[task] fetch 360.75ms
  📌[task] status 12.01ms
  📌[task] log 52.09ms

[connor11son]

Okay solved it. For some reason with my setup it is still adding the 'x-api-key' key to the headers, so just manually removing it solves the issue. Posting my whole config just in case someone comes across this in the future, cheers.

-- Helper function for filtering messages (place this before the plugin configuration)
---@param params table Table containing message and allowed_words
---@return table The filtered message
local function filter_out_messages(params)
  local message = params.message
  local allowed = params.allowed_words

  for key, _ in pairs(message) do
    if not vim.tbl_contains(allowed, key) then
      message[key] = nil
    end
  end
  return message
end

-- Plugin configuration
return {
  {
    'olimorris/codecompanion.nvim',
    dependencies = {
      'nvim-lua/plenary.nvim',
      'nvim-treesitter/nvim-treesitter',
    },
    opts = {
      adapters = {
        anthropic_with_bearer_token = function()
          local utils = require 'codecompanion.utils.adapters'
          local tokens = require 'codecompanion.utils.tokens'

          return require('codecompanion.adapters').extend('anthropic', {
            env = {
              bearer_token = 'ANTHROPIC_BEARER_TOKEN',
            },
            headers = {
              ['content-type'] = 'application/json',
              ['authorization'] = 'Bearer ${bearer_token}',
              ['anthropic-version'] = '2023-06-01',
              ['anthropic-beta'] = 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14',
            },
            handlers = {
              setup = function(self)
                -- Remove x-api-key header if it exists (from base adapter)
                if self.headers and self.headers['x-api-key'] then
                  self.headers['x-api-key'] = nil
                end

                if self.opts and self.opts.stream then
                  self.parameters.stream = true
                end

                local model = self.schema.model.default
                local model_opts = self.schema.model.choices[model]
                if model_opts and model_opts.opts then
                  self.opts = vim.tbl_deep_extend('force', self.opts, model_opts.opts)
                  if not model_opts.opts.has_vision then
                    self.opts.vision = false
                  end
                end

                return true
              end,

              form_messages = function(self, messages)
                -- Same as current form_message but adding Claude Code system message at the first system message
                local has_tools = false

                local system = vim
                  .iter(messages)
                  :filter(function(msg)
                    return msg.role == 'system'
                  end)
                  :map(function(msg)
                    return {
                      type = 'text',
                      text = msg.content,
                      cache_control = nil,
                    }
                  end)
                  :totable()

                -- Add the Claude Code system message at the beginning (required to make it work)
                table.insert(system, 1, {
                  type = 'text',
                  text = "You are Claude Code, Anthropic's official CLI for Claude.",
                  cache_control = {
                    type = 'ephemeral',
                  },
                })

                system = next(system) and system or nil

                messages = vim
                  .iter(messages)
                  :filter(function(msg)
                    return msg.role ~= 'system'
                  end)
                  :totable()

                messages = vim.tbl_map(function(message)
                  if message.opts and message.opts.tag == 'image' and message.opts.mimetype then
                    if self.opts and self.opts.vision then
                      message.content = {
                        {
                          type = 'image',
                          source = {
                            type = 'base64',
                            media_type = message.opts.mimetype,
                            data = message.content,
                          },
                        },
                      }
                    else
                      return nil
                    end
                  end

                  message = filter_out_messages {
                    message = message,
                    allowed_words = { 'content', 'role', 'reasoning', 'tool_calls' },
                  }

                  if message.role == self.roles.user or message.role == self.roles.llm then
                    if message.role == self.roles.user and message.content == '' then
                      message.content = '<prompt></prompt>'
                    end

                    if type(message.content) == 'string' then
                      message.content = {
                        { type = 'text', text = message.content },
                      }
                    end
                  end

                  if message.tool_calls and vim.tbl_count(message.tool_calls) > 0 then
                    has_tools = true
                  end

                  if message.role == 'tool' then
                    message.role = self.roles.user
                  end

                  if has_tools and message.role == self.roles.llm and message.tool_calls then
                    message.content = message.content or {}
                    for _, call in ipairs(message.tool_calls) do
                      table.insert(message.content, {
                        type = 'tool_use',
                        id = call.id,
                        name = call['function'].name,
                        input = vim.json.decode(call['function'].arguments),
                      })
                    end
                    message.tool_calls = nil
                  end

                  if message.reasoning and type(message.content) == 'table' then
                    table.insert(message.content, 1, {
                      type = 'thinking',
                      thinking = message.reasoning.content,
                      signature = message.reasoning._data.signature,
                    })
                  end

                  return message
                end, messages)

                messages = utils.merge_messages(messages)

                if has_tools then
                  for _, m in ipairs(messages) do
                    if m.role == self.roles.user and m.content and m.content ~= '' then
                      if type(m.content) == 'table' and m.content.type then
                        m.content = { m.content }
                      end

                      if type(m.content) == 'table' and vim.islist(m.content) then
                        local consolidated = {}
                        for _, block in ipairs(m.content) do
                          if block.type == 'tool_result' then
                            local prev = consolidated[#consolidated]
                            if prev and prev.type == 'tool_result' and prev.tool_use_id == block.tool_use_id then
                              prev.content = prev.content .. block.content
                            else
                              table.insert(consolidated, block)
                            end
                          else
                            table.insert(consolidated, block)
                          end
                        end
                        m.content = consolidated
                      end
                    end
                  end
                end

                local breakpoints_used = 0
                for i = #messages, 1, -1 do
                  local msgs = messages[i]
                  if msgs.role == self.roles.user then
                    for _, msg in ipairs(msgs.content) do
                      if msg.type ~= 'text' or msg.text == '' then
                        goto continue
                      end
                      if tokens.calculate(msg.text) >= self.opts.cache_over and breakpoints_used < self.opts.cache_breakpoints then
                        msg.cache_control = { type = 'ephemeral' }
                        breakpoints_used = breakpoints_used + 1
                      end
                      ::continue::
                    end
                  end
                end
                if system and breakpoints_used < self.opts.cache_breakpoints then
                  for _, prompt in ipairs(system) do
                    if breakpoints_used < self.opts.cache_breakpoints then
                      prompt.cache_control = { type = 'ephemeral' }
                      breakpoints_used = breakpoints_used + 1
                    end
                  end
                end

                return { system = system, messages = messages }
              end,
            },
          })
        end,
      },
      -- You can add other CodeCompanion options here
      -- strategies = {
      --   chat = {
      --     adapter = "anthropic_with_bearer_token",
      --   },
      --   inline = {
      --     adapter = "anthropic_with_bearer_token",
      --   },
      -- },
    },
  },
}

[stuckinsnow]

This is the one I created, similar but does auto refresh and some other stuff -- https://gist.github.com/stuckinsnow/99e5ab2a779a2ac66e6537d2ca56f51b