accountcraft Install free
All articles

AccountCraft Journal

Shopify Account Custom Fields: No Code First, API Details Too

Learn why Shopify signup cannot require custom fields. Collect data after login with no code apps or a Customer Account UI extension, and review GDPR rules.

14 min read

You cannot require custom fields during Shopify’s New Customer Accounts registration flow. The platform creates an account automatically the moment someone signs in with a new email, with no separate form step to intercept. The practical fix is to store custom data as customer metafields and collect it right after sign-in, either through a no-code app or a developer-built Customer Account UI Extension.

TL;DR:

  • Define customer metafields with narrow data types and validation; use metaobjects for repeatable records such as pets or vehicles, rather than one text field.
  • No code apps suit quick launches; custom Customer Account UI Extensions handle deeper logic but require customer access scopes and protected customer data approval.
  • The metafieldsSet mutation accepts up to 25 inputs, and compareDigest helps prevent customer and staff edits from silently overwriting each other.
  • Customers should be able to edit and delete custom profile data, while consent changes must use the Customer Privacy API rather than ordinary metafields.
  • Metafield data usually survives an app uninstall, but externally stored data must be exported, mapped to Shopify definitions, and tested on a staging store.
Accountcraft
accountcraft.app
Add Custom Account Fields Without Code
AccountCraft lets you personalize Shopify New Customer Accounts with custom data fields, using its Block Builder without coding or theme alterations.
Explore AccountCraft

Table of Contents

How new customer accounts change where you collect custom data

Shopify’s New Customer Accounts work differently from the old registration model. When someone enters an email that isn’t already tied to a profile, Shopify creates the account behind the scenes and sends a one-time passcode. There’s no custom form standing between that email entry and the finished account, so a field you once required at signup (birthday, company name, preferred store) simply has nowhere to live during that moment.

This shift affects any merchant who built a business process around registration-time data capture:

  • You can no longer force a shopper to answer a question before their account exists.
  • Theme-based registration forms stop working because New Customer Accounts don’t run on theme code.
  • Any data you need has to be collected after the account is live, inside the account experience itself.

The Shopify Help Center confirms there’s no supported way to require fields before sign-in. Your options are a Shopify-native feature, an App Store app, or a custom extension, and all three write that data after the fact.

Where custom fields actually live: metafields and metaobjects

Once a customer is signed in, their custom data gets stored as a metafield attached to their profile. A metafield definition has a name, a namespace and key (so “loyalty_tier” doesn’t collide with another app’s “tier” field), a data type (text, number, date, reference), and optional validation rules that stop bad data from getting saved in the first place.

Setting one up in Shopify Admin takes a few deliberate choices:

  • Pick a namespace and key you’ll recognize a year from now, not a generic placeholder.
  • Choose the narrowest type that fits (a date field for a birthday, not free text).
  • Add validation so a “phone number” field can’t accept letters.
  • Pin frequently used fields so your team sees them without digging through the customer page.

For anything more complex than a single value, metaobjects do the heavier lifting. If you’re tracking a customer’s pets, vehicles, or multiple shipping contacts, each of those is really a small record with several fields of its own, and a metaobject keeps that structure intact instead of jamming everything into one long text string.

No-code path: adding fields without touching code

For most merchants, hiring a developer to build and maintain a custom extension isn’t worth it for a handful of profile fields. This is the gap a visual builder like our Block Builder fills: you drop fields, wishlists, and repeatable lists onto the account page the same way you’d arrange theme sections, with no code and no theme file edits.

A few things make this route practical for day-to-day account management:

  • Editable fields, wishlists, repeatable lists, and conditionally visible blocks are added directly on the account page.
  • Fields write to Shopify customer metafields, so data stays inside Shopify Admin and can be used in Flow and other integrated apps.
  • Consent management ties into Shopify’s consent APIs, avoiding the need for a separate privacy tool.
  • This path fits best when you have limited developer time, need to launch quickly, or have to meet GDPR requirements without a custom build.

Pro Tip: Start with the fields your support team asks customers about most often (shipping preferences, sizing, account notes). Those are the ones worth exposing as editable, not buried in a backend note.

Developer path: building a Customer Account UI extension

If you need deeper logic, conditional workflows, or a field type the visual builders don’t support yet, you can build a Customer Account UI Extension that reads and writes metafields directly. The pieces fit together in a fairly linear order.

  1. Declare your metafield in shopify.app.toml, including access.customer_account set to read_write and access.admin set to merchant_read, so the extension is allowed to touch that data.
  2. Add an extension target in shopify.extension.toml pointing at a Profile or account page block, where the field will actually render.
  3. Query the customer’s existing metafields through the Customer Account API and render an editable input pre-filled with whatever value is already stored.
  4. When the customer saves changes, call the metafieldsSet mutation with the correct ownerId and type to write the new value back to their profile.
  5. For stores with concurrent edits (support agents and customers updating the same field close together), include compareDigest on the mutation to get compare-and-swap protection instead of silently overwriting one change with another.

Keep the mutation’s limits in mind while you design the form: metafieldsSet accepts up to 25 metafield inputs in a single call, and every write still depends on your app holding the correct access scopes. Plan for Shopify’s app review timeline before you commit to a launch date, since protected customer data approval doesn’t happen instantly.

Reading or writing customer metafields through an extension requires the customer_read_customers and customer_write_customers access scopes, and any app touching that data needs approval for protected customer data before it goes live. This approval step is one reason an already-approved App Store app can get you moving faster than a from-scratch build.

If your custom fields touch tracking or marketing consent, Shopify’s Customer Privacy API exposes the buyer’s current consent state and lets your extension apply changes when they update their preferences. A few practical notes before you build around it:

  • Your app needs the collect_buyer_consent capability on top of protected customer data access.
  • Consent changes should be applied through the API, not stored as a plain custom metafield that your privacy tooling never sees.
  • Merchants remain responsible for how privacy settings are configured, even when an app handles the technical writes.

Practical checklist before you launch custom account fields

A short sequence of checks before launch saves you from fixing live data problems later.

  1. Create metafield definitions with validation rules first, and pin the ones your team references most in Admin.
  2. Test every field’s write and edit path on a staging store, confirming the app or extension actually holds the access scopes it needs.
  3. Turn on compareDigest for any field that could be updated from two places at once, especially on higher-traffic stores.
  4. Keep consent choices visible on the account page and let customers edit or delete their own data rather than routing requests through support.
  5. Use a metaobject, not a single text field, for anything repeatable like vehicles or pets, so the structure survives future edits.

Pro Tip: Never store personal details in the general “notes” field on a customer profile. Notes aren’t structured, aren’t validated, and aren’t a reliable place to build reporting or automation on top of.

Migrating custom field data between apps or solutions

Switching from one custom-fields app to another, or from a theme-based system to an extension-based one, comes down to one question: where does the old data actually live? If a previous app stored values as standard Shopify metafields under its own namespace, that data usually survives uninstall, and a new app or extension can read it once you point the new field definitions at the same namespace and key.

Two apps mapped to the same metafield slots

The riskier migrations are the ones where data was stored outside Shopify entirely, in an external database tied to the old app’s account. That data doesn’t move automatically. Export it first, in whatever format the outgoing app supports, then map each field to a corresponding metafield definition in the new setup before importing.

A few habits make this smoother regardless of which direction you’re migrating:

  • Document your namespace and key naming before you start, so the new system doesn’t collide with leftover fields from the old one.
  • Migrate on a staging store first and verify a sample of customer records before touching production.
  • Keep repeatable data (like multiple addresses or vehicles) as metaobjects during migration rather than flattening it into single fields, or you’ll lose structure you can’t easily rebuild.
  • Confirm the new app or extension has the access scopes it needs before cutover, so the switch doesn’t leave fields temporarily unreadable.

Budget extra time for GDPR-related fields specifically. Consent records tied to the Customer Privacy API need to carry over accurately, since a gap in consent history during migration can create a compliance blind spot rather than just a data inconvenience.

GDPR considerations for custom field data

Custom fields that capture anything personally identifying, from a birthday to a phone number to a delivery preference, fall under the same GDPR obligations as any other customer data you hold. Keeping that data as Shopify metafields rather than scattering it across spreadsheets or third-party databases makes it easier to honor access and deletion requests, because everything sits in one place your team already knows how to query.

A few practical points matter more for custom fields specifically than for standard account data:

  • Customers should be able to see and edit the custom fields tied to their profile, not just the default name and address fields Shopify shows by default.
  • Deletion requests need to account for custom metafields too, not only order history and default contact details.
  • Consent-related fields should route through the Customer Privacy API rather than a plain custom field, so consent state stays synchronized with how Shopify’s own privacy tooling reads it.
  • Apps touching this data need protected customer data approval, which is itself a checkpoint for whether your data handling meets Shopify’s bar before you even get to GDPR specifics.

None of this replaces a legal review for your specific market and customer base. Treat these points as the technical groundwork, and confirm the legal requirements that apply to where your customers live with someone qualified to advise on that.

Troubleshooting fields that won’t display or save

Most “my custom field isn’t working” problems trace back to one of a handful of causes. A field that doesn’t display usually means the extension target isn’t registered correctly in shopify.extension.toml, or the metafield definition exists but isn’t exposed to the Customer Account API with the right access setting.

A field that displays but won’t save is almost always a scopes or ownership issue. Check that your app has both customer_read_customers and customer_write_customers, that protected customer data access has been approved, and that the ownerId passed into metafieldsSet actually matches the signed-in customer’s ID rather than a stale or incorrect reference.

If a save succeeds intermittently on high-traffic accounts, that’s a sign you need compareDigest for compare-and-swap protection. Without it, two near-simultaneous writes to the same metafield can overwrite each other silently, which looks like a random failure but is really a race condition.

A few other common snags worth checking before you assume something deeper is broken:

  • Confirm the metafield type in your mutation call matches the type set in the definition, since a mismatch fails silently in some cases.
  • Verify the namespace and key in your query match the definition exactly, since a typo creates what looks like a missing field.
  • Check that you haven’t exceeded the 25-metafield cap in a single metafieldsSet call, which returns userErrors rather than a clear failure message.

Comparing no-code apps for custom account fields

No-code apps for Shopify account customization vary mostly in how much structure they let you build without writing code, and how directly they write to Shopify’s own metafield system rather than a separate database. Apps built around visual block builders, including AccountCraft, let you add fields, wishlists, and repeatable lists by arranging blocks on the account page, which suits merchants who want to move fast without developer involvement.

The practical differences worth checking before choosing one:

  • Whether the app writes to genuine Shopify customer metafields, so your data stays portable to Flow and other tools, or locks it into the app’s own storage.
  • Whether repeatable data (pets, vehicles, multiple addresses) is supported as structured metaobjects or flattened into single text fields that lose organization over time.
  • Whether consent and privacy settings are built in and tied to Shopify’s Customer Privacy API, or left for you to configure separately.
  • How much conditional logic is available, such as showing a field only to wholesale customers or loyalty members.

AccountCraft is built around the first option in each case: fields write to metafields, repeatable data stays structured as metaobjects, and consent management ties into Shopify’s APIs rather than a workaround. For merchants who need logic an app’s block library doesn’t cover, a developer-built extension remains the more flexible, higher-effort alternative.

Why a block-based, in-Shopify approach works for merchants

The approach is based on a simple belief: merchants shouldn’t need a developer on retainer just to add a loyalty tier field or a wishlist. Keeping every field as a Shopify metafield means data stays portable to Flow and any app added later, with consent handled in line with Shopify’s expectations.

— Barikreativa

Try AccountCraft to add custom account fields without code

If you’ve read this far wanting the fast route rather than the developer route, that’s exactly what we built AccountCraft for. We give you a visual Block Builder for Shopify’s New Customer Accounts, so you add editable fields, wishlists, and repeatable lists like pets or vehicles without writing a line of code or touching your theme.

Accountcraft

Every field you add writes to a genuine Shopify customer metafield, which means your data stays inside Shopify Admin and works with Flow and your other integrated apps instead of living in a separate database. Consent management comes built in, tied to Shopify’s own Customer Privacy API, so GDPR-related fields don’t need a second tool bolted on.

  • Start on our Free plan to see the Block Builder on your own account pages.
  • Move to Pro or Plus as you add more fields, repeatable lists, or conditional logic.
  • Read our guide to customer metafields and GDPR for a deeper look at how editable fields and consent work together.

Check Free, Pro, and Plus plans and get your first custom field live on your account page today.

FAQ

What does “custom fields” mean?

Custom fields are data points you add beyond Shopify’s default customer information, things like loyalty tier, preferred store, or a pet’s name. In Shopify’s system, they’re stored as customer metafields, each with its own type and validation rules.

Can you make $10,000 a month on Shopify?

Revenue on Shopify depends entirely on your product, pricing, and traffic, so there’s no fixed answer that applies to every store. Stores at that revenue level typically have organized customer data and account experiences that support repeat purchases, which is part of why structured custom fields matter as a store grows.

Does Kim Kardashian use Shopify?

We don’t have verifiable, current information confirming which platform any specific public figure’s brand uses, and that detail isn’t publicly documented in a way we can confirm here. Many large direct-to-consumer brands do run on Shopify, but attributing a specific platform to an individual without a confirmed source isn’t something we can state as fact.

How do I add custom fields?

Create a metafield definition in Shopify Admin with a namespace, key, and type, then expose it on the customer account page through an app or a Customer Account UI Extension, since the Help Center confirms fields can’t be required at sign-up. A no-code app like AccountCraft handles this through a visual builder, while a developer can write and read values directly using the metafieldsSet mutation.

Why can’t I require a field during registration?

Shopify’s New Customer Accounts create a profile automatically the moment someone signs in with a new email, with no separate registration form to insert a required field into. The Third & Grove analysis confirms this is a structural limitation of the current account architecture, not a configuration you can turn on.

Sources