Deno is not just Node with TypeScript built in. It has its own HTTP client, its own permission model, and different assumptions about how outbound connections get made. Fixie's setup on Deno reflects those differences rather than reusing the Node.js snippets.

Deno's secure-by-default permission model blocks network access unless explicitly granted. Any script making outbound requests through Fixie needs --allow-net (or a scoped --allow-net=your-fixie-host.usefixie.com) at runtime, or the connection will fail with a permission error before it ever reaches the proxy.

Using fetch with Deno.createHttpClient

Deno's global fetch doesn't read proxy environment variables the way some other runtimes do. Instead, build an HTTP client bound to the proxy and pass it explicitly on each request:

const fixieUrl = new URL(Deno.env.get("FIXIE_URL")!);

const client = Deno.createHttpClient({
  proxy: { url: fixieUrl.toString() },
});

const response = await fetch("https://api.example.com/data", { client });
console.log(response.status);
console.log(await response.text());

client.close();

Deno.createHttpClient is stable as of Deno 1.x and requires no third-party dependency. This is the idiomatic way to proxy fetch in Deno, unlike Node where fetch needs an agent shim from npm.

Using a proxy agent from npm

Deno's npm compatibility layer can load select npm packages directly, which is useful if you're porting an existing Node integration or prefer axios's proxy config shape over Deno.createHttpClient:

import axios from "npm:axios";

const fixieUrl = new URL(Deno.env.get("FIXIE_URL")!);

const response = await axios.get("https://api.example.com/data", {
  proxy: {
    protocol: "http",
    host: fixieUrl.hostname,
    port: Number(fixieUrl.port) || 80,
    auth: {
      username: fixieUrl.username,
      password: fixieUrl.password,
    },
  },
});

console.log(response.status);

npm compatibility in Deno keeps improving but isn't universal. Some packages that rely on Node-specific internals, such as raw net/tls socket manipulation or certain native addons, won't load cleanly. If a package fails under npm:, check whether it has a native Deno equivalent before assuming Fixie is the problem. The Deno.createHttpClient approach above has no such dependency risk since it uses only Deno's own APIs.

Connecting to a database over Fixie Socks

For Postgres, the postgres client (published for both Node and Deno, and loadable via npm:postgres) accepts a custom socket function, so you can hand it a SOCKS connection through Fixie without a sidecar process:

import postgres from "npm:postgres";
import { SocksClient } from "npm:socks";

const [user, password, host, port] = Deno.env.get("FIXIE_SOCKS_HOST")!
  .split(/[:@]/);

const sql = postgres({
  host: "your-db-host.example.com",
  port: 5432,
  username: Deno.env.get("DB_USER"),
  password: Deno.env.get("DB_PASSWORD"),
  database: Deno.env.get("DB_NAME"),
  ssl: "require",
  socket: async ({ host: dbHost, port: dbPort }) => {
    const { socket } = await SocksClient.createConnection({
      proxy: { host, port: Number(port), type: 5, userId: user, password },
      command: "connect",
      destination: { host: dbHost, port: dbPort },
    });
    return socket;
  },
});

const result = await sql`select 1 as ok`;
console.log(result[0]);
await sql.end();

This keeps everything in one process: no separate binary to run alongside your app. It works for Postgres specifically because postgres's socket option exists for this exact use case. For other databases or arbitrary TCP services without an equivalent option, Fixie-Wrench is the simpler fallback: run it as a sidecar process, and your Deno code just connects to localhost on the forwarded port, no SOCKS client code required.

// Forward localhost:5432 to your database through Fixie Socks, then run:
// ./bin/fixie-wrench 5432:your-db-host.example.com:5432

import { Client } from "npm:pg";

const client = new Client({
  host: "127.0.0.1",
  port: 5432,
  user: Deno.env.get("DB_USER"),
  password: Deno.env.get("DB_PASSWORD"),
  database: Deno.env.get("DB_NAME"),
  ssl: true,
});

await client.connect();
const result = await client.queryObject("select 1 as ok");
console.log(result.rows[0]);
await client.end();

See Connecting to a Database for the general Fixie Socks pattern this builds on.

See the full list of static IP guides for every supported language, platform, and destination.