Typesafe environment variables
with ArkType

Get a strictly typed object from the validator you already use. No boilerplate. Zero dependencies.

./env.ts

import  from "@arkenv/core";

export const  = ({
  : "string.url",
  : "0 <= number.integer <= 65535 = 3000",
  : "boolean = false",
});

import function arkenv<const T extends Record<string, StandardSchemaV1>>(def: T, config?: StandardEnvConfig): StandardEnvOutput<T>Parse and validate environment variables using Standard Schema 1.0 validators (e.g. Zod, Valibot).

This entry is ArkType-free - ArkType is never imported, even transitively.
Use this when your project must not depend on ArkType.
@paramdef An object mapping variable names to Standard Schema validators@paramconfig Optional configuration@returnsThe validated environment variables, or a value-less stub when schema capture is active@throwsAn {@link ArkEnvError} if validation fails@example```ts
import arkenv from "@arkenv/standard";
import * as z from "zod";

const env = arkenv({
  PORT: z.number(),
  HOST: z.string(),
});
```arkenv from "@arkenv/standard";
import * as import zz from "zod";

export const const env: StandardEnvOutput<{
    readonly DATABASE_URL: z.ZodURL;
    readonly PORT: z.ZodDefault<z.ZodInt>;
    readonly CI: z.ZodDefault<z.ZodBoolean>;
}>env = arkenv<{
    readonly DATABASE_URL: z.ZodURL;
    readonly PORT: z.ZodDefault<z.ZodInt>;
    readonly CI: z.ZodDefault<z.ZodBoolean>;
}>(def: {
    readonly DATABASE_URL: z.ZodURL;
    readonly PORT: z.ZodDefault<z.ZodInt>;
    readonly CI: z.ZodDefault<z.ZodBoolean>;
}, config?: StandardEnvConfig): StandardEnvOutput<{
    readonly DATABASE_URL: z.ZodURL;
    readonly PORT: z.ZodDefault<z.ZodInt>;
    readonly CI: z.ZodDefault<z.ZodBoolean>;
}>Parse and validate environment variables using Standard Schema 1.0 validators (e.g. Zod, Valibot).

This entry is ArkType-free - ArkType is never imported, even transitively.
Use this when your project must not depend on ArkType.
@paramdef An object mapping variable names to Standard Schema validators@paramconfig Optional configuration@returnsThe validated environment variables, or a value-less stub when schema capture is active@throwsAn {@link ArkEnvError} if validation fails@example```ts
import arkenv from "@arkenv/standard";
import * as z from "zod";

const env = arkenv({
  PORT: z.number(),
  HOST: z.string(),
});
```arkenv({
  type DATABASE_URL: z.ZodURLDATABASE_URL: import zz.function url(params?: string | z.core.$ZodURLParams): z.ZodURLurl(),
  type PORT: z.ZodDefault<z.ZodInt>PORT: import zz.function int(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodIntint()._ZodNumber<$ZodNumberInternals<number>>.min(value: number, params?: string | z.core.$ZodCheckGreaterThanParams): z.ZodIntmin(0)._ZodNumber<$ZodNumberInternals<number>>.max(value: number, params?: string | z.core.$ZodCheckLessThanParams): z.ZodIntmax(65535).ZodType<any, any, $ZodNumberInternals<number>>.default(def: number): z.ZodDefault<z.ZodInt> (+1 overload)default(3000),
  type CI: z.ZodDefault<z.ZodBoolean>CI: import zz.function boolean(params?: string | z.core.$ZodBooleanParams): z.ZodBooleanboolean().ZodType<any, any, $ZodBooleanInternals<boolean>>.default(def: boolean): z.ZodDefault<z.ZodBoolean> (+1 overload)default(false),
});

import const arkenv: <const T extends Record<string, StandardSchemaV1>>(def: T, config?: StandardEnvConfig) => StandardEnvOutput<T>Parse and validate environment variables with Valibot.

Pre-binds `@valibot/to-json-schema` (`typeMode: "input"`, `target: "draft-07"`)
so `v.number()` and `v.boolean()` coerce without a manual `toJsonSchema`
callback. Install `@valibot/to-json-schema` alongside `valibot`.
@paramdef An object mapping variable names to Valibot schemas@paramconfig Optional configuration. Pass `toJsonSchema` to override the bound converter@returnsThe validated environment variables@throwsAn {@link ArkEnvError } if validation fails@example```ts
import { arkenv } from "@arkenv/standard/valibot";
import * as v from "valibot";

const env = arkenv({
  PORT: v.optional(v.number(), 3000),
  DEBUG: v.optional(v.boolean(), false),
});
```arkenv from "@arkenv/standard/valibot";
import * as import vv from "valibot";

export const const env: StandardEnvOutput<{
    readonly DATABASE_URL: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
    readonly PORT: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>]>, 3000>;
    readonly CI: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}>env = arkenv<{
    readonly DATABASE_URL: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
    readonly PORT: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>]>, 3000>;
    readonly CI: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}>(def: {
    readonly DATABASE_URL: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>;
    readonly PORT: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>]>, 3000>;
    readonly CI: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}, config?: StandardEnvConfig): StandardEnvOutput<...>Parse and validate environment variables using Standard Schema 1.0 validators (e.g. Zod, Valibot).

This entry is ArkType-free - ArkType is never imported, even transitively.
Use this when your project must not depend on ArkType.
@paramdef An object mapping variable names to Standard Schema validators@paramconfig Optional configuration@returnsThe validated environment variables, or a value-less stub when schema capture is active@throwsAn {@link ArkEnvError} if validation fails@example```ts
import arkenv from "@arkenv/standard";
import * as z from "zod";

const env = arkenv({
  PORT: z.number(),
  HOST: z.string(),
});
```arkenv({
  type DATABASE_URL: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]>DATABASE_URL: import vv.pipe<v.StringSchema<undefined>, v.UrlAction<string, undefined>>(schema: v.StringSchema<undefined>, item1: v.UrlAction<string, undefined> | v.PipeAction<string, string, v.UrlIssue<string>>): v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.UrlAction<string, undefined>]> (+20 overloads)
export pipeAdds a pipeline to a schema, that can validate and transform its input.
@paramschema The root schema.@paramitem1 The first pipe item.@returnsA schema with a pipeline.pipe(import vv.function string(): v.StringSchema<undefined> (+1 overload)
export stringCreates a string schema.
@returnsA string schema.string(), import vv.url<string>(): v.UrlAction<string, undefined> (+1 overload)
export urlCreates an [URL](https://en.wikipedia.org/wiki/URL) validation action.

Hint: The value is passed to the URL constructor to check if it is valid.
This check is not perfect. For example, values like "abc:1234" are accepted.
@returnsAn URL action.url()),
  type PORT: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>]>, 3000>PORT: import vv.optional<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>]>, 3000>(wrapped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>]>, default_: 3000): v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<...>]>, 3000> (+1 overload)
export optionalCreates an optional schema.
@paramwrapped The wrapped schema.@paramdefault_ The default value.@returnsAn optional schema.optional(
    import vv.pipe<v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 65535, undefined>>(schema: v.NumberSchema<undefined>, item1: v.IntegerAction<number, undefined> | v.PipeAction<number, number, v.IntegerIssue<number>>, item2: v.MinValueAction<number, 0, undefined> | v.PipeAction<number, number, v.MinValueIssue<number, 0>>, item3: v.MaxValueAction<number, 65535, undefined> | v.PipeAction<number, number, v.MaxValueIssue<number, 65535>>): v.SchemaWithPipe<...> (+20 overloads)
export pipeAdds a pipeline to a schema, that can validate and transform its input.
@paramschema The root schema.@paramitem1 The first pipe item.@paramitem2 The second pipe item.@paramitem3 The third pipe item.@returnsA schema with a pipeline.pipe(
      import vv.function number(): v.NumberSchema<undefined> (+1 overload)
export numberCreates a number schema.
@returnsA number schema.number(),
      import vv.integer<number>(): v.IntegerAction<number, undefined> (+1 overload)
export integerCreates an [integer](https://en.wikipedia.org/wiki/Integer) validation action.
@returnsAn integer action.integer(),
      import vv.minValue<number, 0>(requirement: 0): v.MinValueAction<number, 0, undefined> (+1 overload)
export minValueCreates a min value validation action.
@paramrequirement The minimum value.@returnsA min value action.minValue(0),
      import vv.maxValue<number, 65535>(requirement: 65535): v.MaxValueAction<number, 65535, undefined> (+1 overload)
export maxValueCreates a max value validation action.
@paramrequirement The maximum value.@returnsA max value action.maxValue(65535),
    ),
    3000,
  ),
  type CI: v.OptionalSchema<v.BooleanSchema<undefined>, false>CI: import vv.optional<v.BooleanSchema<undefined>, false>(wrapped: v.BooleanSchema<undefined>, default_: false): v.OptionalSchema<v.BooleanSchema<undefined>, false> (+1 overload)
export optionalCreates an optional schema.
@paramwrapped The wrapped schema.@paramdefault_ The default value.@returnsAn optional schema.optional(import vv.function boolean(): v.BooleanSchema<undefined> (+1 overload)
export booleanCreates a boolean schema.
@returnsA boolean schema.boolean(), false),
});

“Cool project btw! 👍”

Colin McDonnellCreator of Zod

Works with

ArkTypeZodValibotTypeScriptViteNext.jsNuxtSolidStartVercelCloudflareNetlifyNode.jsBunJetBrainsVS CodeCursorClaude Code

Fail-fast at startup

Missing or malformed variables shouldn't silently crash production. ArkEnv fails loudly and early.

$ npm run dev

ArkEnvError: Errors found while validating environment variables
  DATABASE_URL must be a URL string (was [REDACTED])
  PORT must be a number (was a string)

Strictly typed

Strict type inference without glue code. Your schema is the single source of truth.

./app.ts

import { env } from "./env";

const db = env.DATABASE_URLstring
PORTnumber
CIboolean
const port = env.PORT;

Bring your own validator

Use ArkType or any Standard Schema you already have. Mix and match for incremental migration.

./env.ts

export const  = ({
  : "'development' | 'test' | 'production'",
  : .(.(), .()),
  : .(),
});

Full-stack ready

Native integrations for modern frameworks. No server variables leak to the client bundle.

localhost:3000

Runtime Error

Do not access server-only key 'DATABASE_URL' on the client since it will leak sensitive data (prevented by ArkEnv)

app/components/header.tsx (5:12) @ Header

5>    <span>{env.DATABASE_URL}</span>

Automatic coercion

Raw environment variables turn into booleans, numbers, and enums based on your schema.

Structured errors

Each issue gets a code that agents and CI can act on. Missing keys and bad values aren't the same.

{
  "success": false,
  "issues": [
    { "path": "HOST", "code": "MISSING_VARIABLE", "message": "" },
    { "path": "PORT", "code": "INVALID_TYPE", "message": "" }
  ]
}

Start validating with ArkEnv

Read the docs

Typesafe environment variableswith ArkType

Start validating with ArkEnv

Typesafe environment variables
with ArkType