Stripe.Issuing reference

CreateIssuingCard

Source: src/Stripe/CreateIssuingCard.ts

Create a Stripe Issuing Card over HTTP. Account-scoped — binds the API key onto the host, not a specific card resource.

CreateIssuingCard: Creating a Card at runtime

const create = yield* Stripe.CreateIssuingCard();
const card = yield* create({
  cardholder: cardholder.id,
  currency: "usd",
  type: "virtual",
});

CreateIssuingCardholder

Source: src/Stripe/CreateIssuingCardholder.ts

Create a Stripe Issuing Cardholder over HTTP. Account-scoped — binds the API key onto the host, not a specific cardholder resource.

CreateIssuingCardholder: Creating a Cardholder at runtime

const create = yield* Stripe.CreateIssuingCardholder();
const cardholder = yield* create({
  name: "Alice Example",
  billing: {
    address: {
      line1: "123 Main Street",
      city: "San Francisco",
      state: "CA",
      postal_code: "94111",
      country: "US",
    },
  },
});

CreateIssuingCardholderHttp

Source: src/Stripe/CreateIssuingCardholderHttp.ts Kind: Layer · Provides: Stripe.CreateIssuingCardholder

HTTP implementation of CreateIssuingCardholder. Provide it on the Function or Worker Effect.

CreateIssuingCardHttp

Source: src/Stripe/CreateIssuingCardHttp.ts Kind: Layer · Provides: Stripe.CreateIssuingCard

HTTP implementation of CreateIssuingCard. Provide it on the Function or Worker Effect.

IssuingCard

Source: src/Stripe/IssuingCard.ts

A Stripe Issuing Card — a virtual or physical card issued to a Cardholder. cardholder, currency, type, secondLine, and custom expiration are immutable (changing them replaces the card). Status, spending controls, personalization design, and metadata update in place.

Cards cannot be hard-deleted; destroying this resource cancels the card (status: canceled). Canceled cards cannot be reactivated — a later create with the same logical id provisions a new card.

Issuing must be enabled on the Stripe account.

IssuingCard: Creating a Card

Virtual card

const card = yield* Stripe.IssuingCard("expense-card", {
  cardholder: cardholder.id,
  currency: "usd",
  type: "virtual",
  status: "inactive",
});

Spending limits and metadata

const card = yield* Stripe.IssuingCard("expense-card", {
  cardholder: cardholder.id,
  currency: "usd",
  type: "virtual",
  status: "active",
  spendingControls: {
    spendingLimits: [{ amount: 50_000, interval: "monthly" }],
  },
  metadata: { team: "ops" },
});

IssuingCard: Updating a Card

const card = yield* Stripe.IssuingCard("expense-card", {
  cardholder: cardholder.id,
  currency: "usd",
  type: "virtual",
  status: "inactive",
  metadata: { team: "ops", frozen: "true" },
});

IssuingCard: Replacing a Card

const card = yield* Stripe.IssuingCard("expense-card", {
  cardholder: cardholder.id,
  currency: "usd",
  type: "physical",
});

IssuingCardholder

Source: src/Stripe/IssuingCardholder.ts

A Stripe Issuing Cardholder — an individual or company who can be issued cards. Billing address, email, phone, preferred locales, spending controls, status, and metadata update in place. Name and type are immutable; changing them replaces the cardholder.

Stripe does not hard-delete cardholders; destroying this resource sets status to inactive. Inactive cardholders can be reactivated by a later reconcile.

Requires the Stripe Issuing entitlement.

IssuingCardholder: Creating a Cardholder

Individual with billing address

const alice = yield* Stripe.IssuingCardholder("alice", {
  name: "Alice Example",
  type: "individual",
  email: "alice@example.com",
  billing: {
    address: {
      line1: "123 Main Street",
      city: "San Francisco",
      state: "CA",
      postalCode: "94111",
      country: "US",
    },
  },
  individual: { firstName: "Alice", lastName: "Example" },
});

Company cardholder

const acme = yield* Stripe.IssuingCardholder("acme", {
  name: "Acme Corp",
  type: "company",
  billing: {
    address: {
      line1: "1 Market Street",
      city: "San Francisco",
      state: "CA",
      postalCode: "94105",
      country: "US",
    },
  },
  company: { taxId: "12-3456789" },
});

IssuingCardholder: Spending controls

const alice = yield* Stripe.IssuingCardholder("alice", {
  name: "Alice Example",
  billing: {
    address: {
      line1: "123 Main Street",
      city: "San Francisco",
      state: "CA",
      postalCode: "94111",
      country: "US",
    },
  },
  spendingControls: {
    spendingLimits: [{ amount: 10000, interval: "monthly" }],
    spendingLimitsCurrency: "usd",
  },
});

IssuingCardholder: Updating a Cardholder

const alice = yield* Stripe.IssuingCardholder("alice", {
  name: "Alice Example",
  email: "alice+updated@example.com",
  phoneNumber: "+15555550100",
  billing: {
    address: {
      line1: "123 Main Street",
      city: "San Francisco",
      state: "CA",
      postalCode: "94111",
      country: "US",
    },
  },
  metadata: { team: "ops" },
});

IssuingCardholder: Deactivating a Cardholder

// stack.destroy() / resource removal sets status to inactive
const alice = yield* Stripe.IssuingCardholder("alice", {
  name: "Alice Example",
  billing: {
    address: {
      line1: "123 Main Street",
      city: "San Francisco",
      state: "CA",
      postalCode: "94111",
      country: "US",
    },
  },
});

IssuingPersonalizationDesign

Source: src/Stripe/IssuingPersonalizationDesign.ts

A Stripe Issuing Personalization Design — a physical bundle, optional card logo, and optional carrier text that represent a card product line. Name, lookup key, logo, carrier text, physical bundle, preferences, and metadata update in place.

Stripe has no delete, archive, or deactivate API for personalization designs. Destroy is a no-op; the design remains as residue on the account (still listed by list() via Alchemy metadata). Account-wide nuke skips this type.

Creating designs requires the Stripe Issuing entitlement.

IssuingPersonalizationDesign: Creating a Personalization Design

Named design on a physical bundle

const design = yield* Stripe.IssuingPersonalizationDesign("metal-card", {
  physicalBundle: "ics_Fiiwz3T83opOUd",
  name: "Metal Card",
});

Lookup key, carrier text, and metadata

const design = yield* Stripe.IssuingPersonalizationDesign("metal-card", {
  physicalBundle: "ics_Fiiwz3T83opOUd",
  name: "Metal Card",
  lookupKey: "metal_card_v1",
  carrierText: {
    headerTitle: "Welcome",
    headerBody: "Your card is on its way.",
  },
  metadata: { line: "metal" },
});

IssuingPersonalizationDesign: Updating a Personalization Design

const design = yield* Stripe.IssuingPersonalizationDesign("metal-card", {
  physicalBundle: "ics_Fiiwz3T83opOUd",
  name: "Metal Card v2",
  lookupKey: "metal_card_v1",
  metadata: { line: "metal", version: "2" },
});

IssuingPersonalizationDesign: Retrieving a Personalization Design

const retrieve = yield* Stripe.RetrieveIssuingPersonalizationDesign(design);
const live = yield* retrieve();

IssuingPersonalizationDesign: Destroying a Personalization Design

// stack.destroy() leaves the Stripe object in place — there is no
// delete/archive API. Residue stays tagged with alchemy_stack.
const design = yield* Stripe.IssuingPersonalizationDesign("metal-card", {
  physicalBundle: "ics_Fiiwz3T83opOUd",
  name: "Metal Card",
});

RetrieveIssuingCard

Source: src/Stripe/RetrieveIssuingCard.ts

Retrieve a bound Stripe Issuing Card over HTTP.

RetrieveIssuingCard: Reading a Card

const retrieve = yield* Stripe.RetrieveIssuingCard(card);
const live = yield* retrieve();

RetrieveIssuingCardholder

Source: src/Stripe/RetrieveIssuingCardholder.ts

Retrieve a bound Stripe Issuing Cardholder over HTTP.

RetrieveIssuingCardholder: Reading a Cardholder

const retrieve = yield* Stripe.RetrieveIssuingCardholder(alice);
const live = yield* retrieve();

RetrieveIssuingCardholderHttp

Source: src/Stripe/RetrieveIssuingCardholderHttp.ts Kind: Layer · Provides: Stripe.RetrieveIssuingCardholder

HTTP implementation of RetrieveIssuingCardholder. Provide it on the Function or Worker Effect.

RetrieveIssuingCardHttp

Source: src/Stripe/RetrieveIssuingCardHttp.ts Kind: Layer · Provides: Stripe.RetrieveIssuingCard

HTTP implementation of RetrieveIssuingCard. Provide it on the Function or Worker Effect.

RetrieveIssuingPersonalizationDesign

Source: src/Stripe/RetrieveIssuingPersonalizationDesign.ts

Retrieve a bound Stripe Issuing Personalization Design over HTTP.

RetrieveIssuingPersonalizationDesign: Reading a Personalization Design

const retrieve = yield* Stripe.RetrieveIssuingPersonalizationDesign(design);
const live = yield* retrieve();

RetrieveIssuingPersonalizationDesignHttp

Source: src/Stripe/RetrieveIssuingPersonalizationDesignHttp.ts Kind: Layer · Provides: Stripe.RetrieveIssuingPersonalizationDesign

HTTP implementation of RetrieveIssuingPersonalizationDesign. Provide it on the Function or Worker Effect.

UpdateIssuingCard

Source: src/Stripe/UpdateIssuingCard.ts

Update a bound Stripe Issuing Card over HTTP.

UpdateIssuingCard: Updating a Card

const update = yield* Stripe.UpdateIssuingCard(card);
const live = yield* update({ status: "inactive" });

UpdateIssuingCardholder

Source: src/Stripe/UpdateIssuingCardholder.ts

Update a bound Stripe Issuing Cardholder over HTTP.

UpdateIssuingCardholder: Updating a Cardholder

const update = yield* Stripe.UpdateIssuingCardholder(alice);
const live = yield* update({ email: "alice@example.com" });

UpdateIssuingCardholderHttp

Source: src/Stripe/UpdateIssuingCardholderHttp.ts Kind: Layer · Provides: Stripe.UpdateIssuingCardholder

HTTP implementation of UpdateIssuingCardholder. Provide it on the Function or Worker Effect.

UpdateIssuingCardHttp

Source: src/Stripe/UpdateIssuingCardHttp.ts Kind: Layer · Provides: Stripe.UpdateIssuingCard

HTTP implementation of UpdateIssuingCard. Provide it on the Function or Worker Effect.