DEV Community

Mohamed Bal
Mohamed Bal

Posted on

Claude Code in Algeria: A Practical Setup with Local DZD Billing

#claudecode #ai #programming #tutorial

Disclosure: Claude Code is a third-party product. DEVUP AI is an independent platform and is not affiliated with or endorsed by the Claude Code publisher.

For many developers, installing an AI coding agent is the easy part.

Paying for it is not.

In Algeria, a developer may have the skills, the repository, and the use case—but still be blocked by a payment flow that expects an international card or a foreign billing account.

That is the problem this integration is designed to remove.

DEVUP AI lets Algerian developers connect Claude Code to a locally billed AI account, use a supported tool-capable model, and pay in Algerian dinars through local payment methods.

This guide covers the public integration surface only. It does not require a custom proxy on your machine, a modified Claude Code binary, or changes to your application source code.

What Claude Code actually does

Claude Code is not an autocomplete box. It is an agentic coding tool that can inspect a repository, read and edit files, run terminal commands, execute tests, and work across multiple steps of a development task.

It is available in the terminal and supported editor environments. The official documentation also supports routing terminal and editor sessions through an LLM gateway by configuring a base URL and a gateway credential.

Claude Code running in a terminal

Official Claude Code product image. Source: Claude Code.

With DEVUP AI, the developer experience remains familiar:

  1. Open a project.
  2. Start Claude Code.
  3. Describe the task.
  4. Review the plan and permissions.
  5. Inspect the changes and verification results.

The difference is the account used for model access and billing.

What you need

Before starting, prepare:

  • A Windows, macOS, Linux, or WSL environment supported by Claude Code.
  • A DEVUP AI account.
  • A DEVUP AI API key.
  • A model ID from the DEVUP AI catalogue that supports tool calling.
  • A repository you are allowed to inspect and modify.

Important: DEVUP AI provides access to more than 200 models overall, but catalogue size is not the same as Claude Code compatibility. An agentic coding loop requires a model that can call tools. Select a model explicitly documented or verified for tool use.

Create your key from the DEVUP AI API Keys dashboard, and select a compatible model from the model catalogue.

Never paste a real API key into an article, screenshot, Git repository, issue, or shared configuration file.

Step 1: Install Claude Code

Windows 11 with PowerShell

The cleanest Windows installation uses WinGet:

winget install Anthropic.ClaudeCode
Enter fullscreen mode Exit fullscreen mode

Close and reopen PowerShell after installation, then run the read-only diagnostic command:

claude doctor
Enter fullscreen mode Exit fullscreen mode

macOS, Linux, or WSL

Use the official native installer:

curl -fsSL https://claude.ai/install.sh | bash
Enter fullscreen mode Exit fullscreen mode

Then verify the installation:

claude doctor
Enter fullscreen mode Exit fullscreen mode

Installation commands can change. If either command differs on your system, use the current official installation guide.

Step 2: Configure a temporary PowerShell session

Start with temporary environment variables. They apply only to the current PowerShell window, which makes the first test easy to isolate and undo.

Replace the API key and model placeholder before running the commands:

$env:DEVUP_API_KEY = "sk-devup-REPLACE_ME"
$env:ANTHROPIC_BASE_URL = "https://api.devupai.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN = $env:DEVUP_API_KEY
$env:ANTHROPIC_MODEL = "YOUR_TOOL_CAPABLE_MODEL_ID"
$env:CLAUDE_CODE_MAX_OUTPUT_TOKENS = "32000"
Enter fullscreen mode Exit fullscreen mode

Move into your project and start Claude Code normally:

cd C:\path\to\your-project
claude
Enter fullscreen mode Exit fullscreen mode

You do not need --bare for the standard setup. Bare mode intentionally skips project instructions, hooks, skills, plugins, MCP servers, subagents, auto memory, and CLAUDE.md discovery. That makes it useful for specific minimal workflows, but it is not the right default for a normal coding session.

Step 3: Configure Bash or Zsh

On macOS, Linux, or WSL, use the equivalent shell exports:

export DEVUP_API_KEY="sk-devup-REPLACE_ME"
export ANTHROPIC_BASE_URL="https://api.devupai.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="$DEVUP_API_KEY"
export ANTHROPIC_MODEL="YOUR_TOOL_CAPABLE_MODEL_ID"
export CLAUDE_CODE_MAX_OUTPUT_TOKENS="32000"
Enter fullscreen mode Exit fullscreen mode

Then launch Claude Code from the repository:

cd /path/to/your-project
claude
Enter fullscreen mode Exit fullscreen mode

These exports disappear when the terminal session closes. That is desirable during initial verification.

Step 4: Verify the connection before editing code

Inside Claude Code, run:

/status
Enter fullscreen mode Exit fullscreen mode

Check that:

  • The base URL points to https://api.devupai.com/anthropic.
  • The active credential is the environment token you configured.
  • The intended model ID is selected.

Then send a harmless read-only prompt:

Inspect this repository without modifying any files.

1. Summarize the project structure.
2. Identify the package manager.
3. Identify the existing lint, type-check, and test commands.
4. List the files you would inspect first for a bug in the authentication flow.
5. Stop and wait for approval before making changes.
Enter fullscreen mode Exit fullscreen mode

This first task validates more than text generation. A successful response should show that the agent can inspect the repository, reason across files, and respect an explicit no-edit boundary.

Step 5: Run a controlled coding task

Do not begin with a production migration or a large autonomous refactor. Start with a small task that has a measurable completion condition.

For example:

Investigate the failing authentication test.

Before editing:
- reproduce the failure;
- identify the root cause;
- propose the smallest safe fix;
- list the files that need to change.

After I approve the plan:
- implement only the approved changes;
- run the existing lint, type-check, and test commands;
- report every modified file;
- include any remaining failure or uncertainty.
Enter fullscreen mode Exit fullscreen mode

This structure forces a useful engineering sequence:

Inspect → Reproduce → Plan → Approve → Edit → Verify → Report
Enter fullscreen mode Exit fullscreen mode

The model is important, but the workflow matters just as much. A powerful model with an ambiguous instruction can make broad, unnecessary changes. A constrained task with explicit verification produces a result that is easier to review and trust.

Step 6: Review the result like an engineer

Claude Code can execute tools, but it should not replace your review process.

Before accepting a change:

  • Read the complete diff.
  • Confirm that no secrets or environment files were added.
  • Check that the agent used existing project conventions.
  • Verify that tests actually ran rather than being described hypothetically.
  • Inspect commands before approving anything destructive or irreversible.
  • Re-run critical checks yourself before deployment.

The correct mental model is not “the agent wrote it, therefore it works.”

It is:

The agent produced a candidate change and evidence. I still own the decision to merge it.

Optional: Configure the VS Code extension

The VS Code extension performs its own credential check. If the terminal configuration is not detected by the extension, open:

Claude Code in VS Code

Official Claude Code editor image. Source: Claude Code.

Command Palette → Preferences: Open User Settings (JSON)
Enter fullscreen mode Exit fullscreen mode

Add the gateway variables to user settings, not to a repository-level workspace file:

{
  "claudeCode.environmentVariables": [
    {
      "name": "ANTHROPIC_BASE_URL",
      "value": "https://api.devupai.com/anthropic"
    },
    {
      "name": "ANTHROPIC_AUTH_TOKEN",
      "value": "sk-devup-REPLACE_ME"
    },
    {
      "name": "ANTHROPIC_MODEL",
      "value": "YOUR_TOOL_CAPABLE_MODEL_ID"
    },
    {
      "name": "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
      "value": "32000"
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Restart the extension and use /status again.

Storing a key in local user settings is more persistent than a temporary shell export. Protect the device, never put the key in workspace settings, and rotate it immediately if it is exposed.

Troubleshooting

Claude Code still shows a login screen

Confirm that ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN exist in the same shell that launches claude.

On PowerShell:

if ($env:ANTHROPIC_BASE_URL) { "Base URL is set" }
if ($env:ANTHROPIC_AUTH_TOKEN) { "Auth token is set" }
Enter fullscreen mode Exit fullscreen mode

On Bash or Zsh:

test -n "$ANTHROPIC_BASE_URL" && echo "Base URL is set"
test -n "$ANTHROPIC_AUTH_TOKEN" && echo "Auth token is set"
Enter fullscreen mode Exit fullscreen mode

Do not print the token itself.

The request returns 401

The key is missing, malformed, expired, or revoked. Generate or rotate the key in the DEVUP AI dashboard, update the environment variable, and retry.

The model is reported as unavailable

Copy the model ID exactly as published in the DEVUP AI catalogue. Model resolution is strict; a typo should fail rather than silently selecting a different model.

The agent responds with text but does not use tools

The selected model may not support the tool-calling behavior required by Claude Code. Switch to a model explicitly verified for agentic tool use.

A request exceeds the output-token limit

Keep:

CLAUDE_CODE_MAX_OUTPUT_TOKENS=32000
Enter fullscreen mode Exit fullscreen mode

The DEVUP AI Messages-compatible endpoint currently documents a maximum of 32,768 output tokens. Setting the client ceiling slightly below that limit prevents the client from requesting an unsupported value.

You see an unrecognized-model notice

Claude Code may display a client-side notice when a model ID is not part of its built-in model list. The notice alone does not prove that the request failed. Check the actual response and /status output.

What this setup does—and does not do

This integration is intended for local Claude Code CLI and supported editor workflows.

It does not redirect Claude Code sessions running on the product’s hosted web or mobile surfaces. Some account-dependent features, including Remote Control and voice dictation, are also unavailable while a gateway credential is active.

That distinction matters: configuring the terminal does not silently change every Claude Code surface associated with a user.

Why local billing matters

AI coding agents are becoming part of the software development toolchain. Access should not depend on whether a developer happens to own a foreign card.

DEVUP AI turns that payment barrier into a local developer workflow:

  • Create an account locally.
  • Fund it in Algerian dinars.
  • Generate an API key.
  • Connect the tools you already use.
  • Track usage from one dashboard.

The important change is operational: an Algerian developer can access an agentic coding workflow using local payment rails and a locally billed balance.

The final configuration

For a temporary PowerShell session, the complete configuration is:

$env:DEVUP_API_KEY = "sk-devup-REPLACE_ME"
$env:ANTHROPIC_BASE_URL = "https://api.devupai.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN = $env:DEVUP_API_KEY
$env:ANTHROPIC_MODEL = "YOUR_TOOL_CAPABLE_MODEL_ID"
$env:CLAUDE_CODE_MAX_OUTPUT_TOKENS = "32000"

cd C:\path\to\your-project
claude
Enter fullscreen mode Exit fullscreen mode

Then verify with /status, begin with a read-only repository inspection, approve a minimal plan, and require the agent to run the project’s existing checks.

Start building

Read the DEVUP AI Claude Code setup guide, review the Messages-compatible API documentation, and create an API key from the DEVUP AI dashboard.

If you try the integration, I would like to know what you built, which development environment you used, and where the workflow still needs improvement.

I am Mohamed Bal, Founder and CTO of DEVUP AI, an Algeria-built AI infrastructure platform providing unified model APIs, GPU and CPU cloud compute, and local DZD billing for developers.

References

Top comments (0)