Email signup and Kit
Forma includes optional email signup in a page section or newsletter popup, plus a separate optional marketing choice during demo access. The site remains a static landing page. You connect your own Kit Form or receiving endpoint; Forma supplies no email account, mailing backend, subscriber database or delivery service. One setting selects where the same signup component appears, so the page does not embed two copies of your Form.
By default, newsletter signup stays in its page section and Get started opens the separate, non-collecting name/email demo-access scenario. The email section only handles mailing-list signup; it never grants demo access. Set demoAccess.mode: 'kit' to add a separate optional marketing choice to demo access. Newsletter placement: 'dialog' makes exact #newsletter actions open a newsletter popup, while { kind: 'demo' } continues to open demo access. See demo access with optional email signup and Customization.
Affiliate disclosure: this guide includes an optional Kitee referral link to Kit. We may earn a commission on qualifying paid purchases. A direct non-affiliate option is provided too; your included Forma features and support are the same whichever you choose.
The supplied setting is preview: with JavaScript available, visitors can try the sample form and see a clearly labelled demo confirmation. No email is sent, no subscription is created, and Forma does not save or transmit the entered address or checkbox choice. No provider script is requested. Without JavaScript, the preview fields and button stay disabled so they cannot submit to the current page. Before enabling real collection, replace the example wording, configure a real privacy-policy link and test the whole subscriber journey.
On this page
- Choose a mode
- Try the non-collecting preview
- Choose a page section or popup
- Use Forma's own form with Kit
- Kit terms, branding and separate service
- Security and data flow
- Optional: support Forma's development
- 1. Create your own inline Kit Form
- 2. Configure consent and confirmation in Kit
- 3. Copy the Kit-issued embed values
- 4. Review loading and updates
- 5. Test the complete Kit journey
- Alternative: connect your own endpoint
- Test demo access separately
- Keep the newsletter optional
Choose a mode
All shared settings are in src/config/site.ts, under siteSettings.newsletter. Visible headings, labels, consent wording and messages are in both content files under newsletter.
| Mode | Behaviour | What you provide |
|---|---|---|
preview | Enables a local demo after JavaScript loads; valid submission opens an explicitly labelled demo confirmation. No collection or external request. | Nothing; replace this mode before using a real signup. |
disabled | Hides newsletter signup in either placement. | Change any signup CTA to a useful link. |
kit | Automatically loads your Kit-designed Inline Form when its presentation mounts; an optional interaction gate is available. | A published inline Kit Form for each language slot, its exact UID/script URL and an optional HTTPS share URL. |
kit-native | Shows Forma-styled fields immediately and sends a valid, consented newsletter request to Kit in the background. | Public Inline Form values plus numeric Form/tag IDs, the name-field mapping and the published reCAPTCHA setting. |
endpoint | Shows a Forma-styled email form with an unchecked required marketing-consent checkbox; submits a normal HTML POST. | A working public receiving URL and its expected field names. |
The newsletter popup is optional. Choose its placement below, or use direct links as shown in Customization. Do not leave an action targeting disabled signup.
Try the non-collecting preview
In preview mode, enter a sample address such as you@example.com, leave the checkbox unchecked and try submitting. A theme-matched message must explain the missing choice and focus must move to the checkbox. Then check it and submit again with the valid sample address. Both a valid email address and a checked box are required for the demo; the box starts unchecked. These are interface checks, not a real subscription or a saved consent record.
After a valid submission, the email field and checkbox reset and a popup shows a success message marked demo confirmation. Its explanation states that no email was sent, no subscription was created and the details were not saved or transmitted. Dismiss it with the close control, Got it or Escape; keyboard focus returns to the form's submit button. Labels are translated in both supplied languages. An invalid address, an empty field or an unchecked checkbox must not show this popup.
This works in the page section and when signup is inside the newsletter popup. In the latter placement, dismissing the confirmation leaves the original signup popup open. Forma holds any unfinished input only in the current page's form until it is reset or the page is left; it writes no preview input to cookies or local storage. The preview never loads Kit, sends a POST or confirms delivery. The two Kit modes use the actual provider response, and endpoint mode uses your receiver response; none receives this simulated success popup.
Customize the preview note and confirmation wording under newsletter in both src/content/primary.ts and secondary.ts: previewNote, previewConfirmationLabel, previewSuccessTitle, previewSuccessDescription, previewCloseLabel and previewDoneLabel. Keep the demo status and non-collection explanation clear if you change them. Rebuild after editing.
Preview, endpoint and native Kit forms use the browser's email/required validity rules, with translated inline errors after JavaScript loads. Edit newsletter.emailError and newsletter.consentError in both content files. On an invalid submission, the fields are identified to assistive technology, the first invalid field receives focus, and each message clears when that field is corrected. No additional email-pattern rule is imposed. The real checkbox follows the site's theme and keeps visible keyboard focus; forced-colors mode uses the browser's native checkbox. Fields/messages in the Kit-designed embed remain under Kit's control; native fields use the Forma dictionaries.
Choose a page section or popup
Inside the existing siteSettings.newsletter object in src/config/site.ts, use:
placement: 'section',
This is the default. Signup appears as a page section after the FAQ, and links to #newsletter scroll there. To put the same signup in a newsletter popup instead, change this field:
placement: 'dialog',
Expected result: the newsletter section is hidden. CTA and navigation entries with the exact destination #newsletter open newsletter signup; the supplied pricing and final CTA already use that destination. { kind: 'demo' }, including the default Get started action, opens the separate demo-access flow. To use Get started for newsletter signup instead, set headerAction: { kind: 'link', href: '#newsletter' }. Ordinary checkout destinations remain ordinary links. A URL fragment by itself does not open the popup; activate a page control.
The popup uses newsletter.eyebrow, title, description and closeLabel from the active content file. Edit those fields in both src/content/primary.ts and secondary.ts. Kit-designed embed labels and messages are configured in Kit; native fields use Forma content. All enabled newsletter modes support either placement.
Use a Kit Inline Form in both placements. Forma supplies the dialog; do not select Kit's own Modal or Slide in format, which would add a separate provider-controlled popup. No affiliate link is inserted into either runtime placement.
The newsletter Form mounts on its first opening. Closing the newsletter popup keeps it mounted for reopening during that page visit. Switching that shared dialog to the separate demo-access flow replaces the displayed flow and resets newsletter interface state; do not treat the popup as persistent storage. Demo access resets on closing. Closing a popup does not unload a provider script, cancel an accepted request, revoke provider storage or unsubscribe. Restore placement: 'section' and rebuild to move newsletter signup back onto the page. See Cookies.
Use Forma's own form with Kit
Advanced custom adapter — provider clarification pending: this option was functionally tested, but its use of Kit handler internals goes beyond the documented embed example. Obtain Kit's written clarification for this custom commercial integration before presenting it as approved or publishing it for production use. The standard Kit-designed embed is the documented alternative.
Choose mode: 'kit-native' for the mailing-list section or newsletter popup. Its email field, required unchecked consent choice, button, validation and messages use Forma's design and translations. Fields appear immediately; there is no Load or ready button. Only a valid submission with the required marketing choice starts the optional Kit handler and background request. The page stays in place. Kit remains the service storing subscribers, handling confirmation and unsubscribe; Forma adds no backend, account authentication or private API credentials.
First follow the Inline Form, consent, confirmation and return-visitor steps below. Add Kit's First Name custom field and leave it optional for a newsletter Form that only sends email. Configure a permission Tag → Checkboxes choice. Keep the wording and versioned tag consistent with the consent copy in both Forma dictionaries. Then publish and inspect Embed → JavaScript, HTML and Share:
| Setting | Exact source in Kit's generated code |
|---|---|
uid, scriptUrl | JavaScript tag's data-uid and src |
shareUrl | Complete HTTPS URL in the Share tab; required for native fallback |
native.formId | Numeric data-sv-form in the HTML Form; not its UID |
native.consentTagId | Numeric value of your chosen name="tags[]" checkbox |
native.firstNameField | Exact First Name input name; tested as fields[first_name] |
native.recaptcha | The true/false value of settings.recaptcha.enabled in the HTML data-options |
The issued Form action must be exactly https://app.kit.com/forms/YOUR_NUMERIC_FORM_ID/subscriptions with that same numeric ID. The supplied adapter constructs only this trusted public action. If Kit gives different metadata, action or handler code, stop and request a reviewed integration update. Do not disable validation or put an API URL/key into these fields. Copy the actual reCAPTCHA flag; do not turn off a provider setting to make a test pass. The adapter preserves Kit's verification steps when configured.
Copy-and-paste native newsletter configuration
In src/config/site.ts, add this public-data object after the imports and before export const siteSettings. Replace every uppercase placeholder with your own issued values; these placeholders are intentionally not a working connection:
const newsletterKitForm = {
uid: 'YOUR_NEWSLETTER_UID',
scriptUrl: 'https://your-account.kit.com/YOUR_NEWSLETTER_UID/index.js',
shareUrl: 'https://your-account.kit.com/YOUR_NEWSLETTER_UID',
native: {
formId: 'YOUR_NUMERIC_NEWSLETTER_FORM_ID',
consentTagId: 'YOUR_NUMERIC_PERMISSION_TAG_ID',
firstNameField: 'fields[first_name]',
recaptcha: false, // Copy the actual enabled flag from your issued HTML.
},
};
Inside the existing siteSettings.newsletter object, replace these entries, preserving its endpoint block:
mode: 'kit-native',
placement: 'section',
privacyPolicyHref: 'https://your-domain.example/privacy/',
consentVersion: 'newsletter-2026-10',
formId: 'product-updates',
kit: {
primary: newsletterKitForm,
secondary: newsletterKitForm,
},
This deliberately reuses one provider Form for a first connection test. Forma's own labels/messages translate, but the provider's confirmation email, tags and verification pages remain configured in Kit. For distinct provider language content, define a second public-data object from a separately translated Form and use it in secondary. Keep published notice/source records yourself; consentVersion and formId are not automatically submitted to Kit.
Demo access with optional email signup
The default demoAccess.mode: 'preview' remains a local demonstration that sends nothing. Choose demoAccess.mode: 'kit' to keep Access the demo, name and email fields, plus a separate optional, unchecked marketing choice. Without that choice, valid input reveals the configured demo continuation with no Kit subscription request. With the choice, Kit receives name/email and the configured permission tag in the background; the same demo continuation remains available independently of the request's result. This is access to your configured public demo destination, not sign-in, registration or protection of that URL.
If both a real newsletter and real demo signup are enabled, create a separate Kit Inline Form for demo signup, with its own UID and numeric Form ID. Duplicate your provider Form, rename it, verify its settings, and publish it. Reusing an active newsletter Form for demo access is rejected at build time to avoid duplicate provider instances. Reusing a Form across the two language slots within one purpose is allowed deliberately.
Add another object above siteSettings with that separate Form's values:
const demoKitForm = {
uid: 'YOUR_DEMO_UID',
scriptUrl: 'https://your-account.kit.com/YOUR_DEMO_UID/index.js',
shareUrl: 'https://your-account.kit.com/YOUR_DEMO_UID',
native: {
formId: 'YOUR_NUMERIC_DEMO_FORM_ID',
consentTagId: 'YOUR_NUMERIC_PERMISSION_TAG_ID',
firstNameField: 'fields[first_name]',
recaptcha: false, // Copy this Form's actual setting.
},
};
Replace the existing demoAccess property inside siteSettings with:
demoAccess: {
mode: 'kit',
kit: {
primary: demoKitForm,
secondary: demoKitForm,
},
},
Keep headerAction: { kind: 'demo' }; set dialogAction to a normal link to your real demo destination. The supplied destination is #product. The email section stays mailing-list-only. If you need actual authentication, link to your own application's login system; Kit subscription confirmation is not account authentication.
Edit dialog.kitFormNote, kitSuccessDescription, the regular demo labels and newsletter.consentLabel in both content files. The demo notice must explain optional name/email transfer to Kit. Closing resets demo fields; it does not cancel an already submitted request. After a request is sent, continue checking the actual provider record and inbox even if you close the popup.
Background response and fallback
Both native forms use Kit's official public HTML-form handler, loaded only after valid opted-in submission. Forma does not replace its transport with an unauthenticated API call or claim success from an opaque response. The current adapter observes the provider's completion/errors, preserves verification UI and shows request received, error or result not yet known. Request received does not mean confirmed, delivered or subscribed for marketing. Complete the separate confirmation email and verify the actual permission tag and subscriber status. A 45-second wait becomes unknown, never fabricated success; check the inbox/provider or use the required hosted fallback before retrying.
The adapter depends on the currently tested Kit handler's initialization and completion behavior. Provider changes may require a template integration update. Do not modify its guards or treat a script-load event as acceptance. Without JavaScript, a native newsletter section renders disabled controls and a usable hosted Form link. Popups require JavaScript to open; this is also why the demo-access form is unavailable without JavaScript. No name/email/consent is saved by Forma to browser storage. Kit can use provider storage and receive page/referrer information when initialized; review your real provider behavior and policy.
Forma permits one Kit signup request at a time on the current page, across both the Kit-designed embed and Forma-styled forms. This prevents overlapping provider verification from confirming the wrong request. A second attempt is stopped before it is sent and shows newsletter.requestBusyMessage; the configured hosted fallback remains available. Demo continuation stays independent of marketing: it must still work when signup is blocked. Reopening a native form with the exact same details can follow its existing pending or unknown request without sending it twice.
The shared request lock remains while the result is pending or unknown, including after closing a popup or switching its purpose. Closing does not cancel an accepted request or unlock another signup. The existing provider completion/error can still settle that request after its original form view is gone. A timeout is an unknown result, not success or permission to send again. Complete any verification and check your inbox/provider before retrying or using the hosted fallback. The lock belongs to this page, not a backend or cross-tab system: reloads, language navigation and other tabs cannot cancel a request already sent or guarantee duplicate protection.
For both the Kit-designed embed and native signup, Forma places Kit's actual verification element in a separate top-layer dialog so it stays interactive above a Forma popup. Kit's markup and callbacks are retained; Close and Escape use the provider's own close action, and Kit still decides the outcome. This wrapper does not solve or bypass verification. Test focus, close/reopen and the actual provider journey before publishing; an offline verification fixture does not establish a real CAPTCHA pass.
Kit terms, branding and separate service
The standard embed and editable raw HTML are described in Kit's embedding guide. This is evidence for ordinary embedding, not a statement that Kit has approved Forma's custom background adapter. Its SDK initialization/completion details are not a documented commercial integration contract. Review the current service terms and obtain clarification from Kit for that custom mode before production use.
The Forma-styled native newsletter and demo-access forms always retain the provider-issued Built with Kit text badge and destination, including the demo response view. This release provides no configuration switch for removing that native attribution. Keep it visible while the custom adapter awaits provider clarification.
Kit permits removing its badge only on eligible paid plans. If you need that supported option, use the standard Kit-designed embed (newsletter.mode: 'kit') and manage branding through Kit's own Form settings after confirming your eligibility. Verify the newly published embed. Do not hide branding with CSS or use a custom form as a free-plan branding bypass. Forma does not detect your plan or change your Kit account. Editable frontend source cannot make attribution tamper-proof; buyers remain responsible for following Kit's terms. The standard provider attribution URL remains separate from Kitee's optional affiliate link. See Kit's badge rules.
Each buyer connects their own Kit account and is responsible for that service's terms, plan allowances, acceptable use and permission-based audience. Forma neither resells Kit service nor transfers rights to Kit's software, logos or trademarks. Forma is an independent Kitee product, not sponsored or endorsed by Kit. Kitee separately participates in Kit's affiliate program, disclosed beside the optional referral link; affiliate membership is not technical approval of this integration. Review Kit's acceptable-use policy and affiliate terms where applicable.
Security and data flow
Forma's Kit connection needs public Form metadata only, never your password, account API key or private token. Native requests use a fixed HTTPS Kit Form destination, numeric ID/tag validation and restricted field names. Email and name are put into form values, not added to Forma's navigation URLs. Provider errors are displayed as text. The template does not create a local subscriber database or save those entries to browser storage.
The native checkbox controls the normal user journey; it is not cryptographic evidence or protection against someone sending requests directly to a public Form. Keep Kit's verification and double opt-in configured, and send marketing only to active confirmed subscribers with the intended permission. Keep the notice history and records your actual use requires. Demo continuation is a public link, not account authentication.
Spam-protection responsibility for this release: Forma is a frontend-only template and does not include its own server-side anti-spam or rate-limiting service. Browser validation, a consent checkbox and duplicate-button handling cannot prevent automated requests. Before enabling real collection, the buyer/site operator is responsible for configuring and testing suitable spam and abuse protection through Kit or their chosen provider, or implementing it on their own receiving backend. Double opt-in helps verify mailbox access; it does not by itself prevent bots or abusive submissions. No future Forma backend or anti-spam release is promised.
Kit's script runs as third-party code on the page and can access page content. Loading it means trusting the provider; its service, storage, spam checks and future code remain outside Forma's control. The current adapter needs retesting after provider changes and keeps error/unknown states plus a hosted fallback. It never turns a timeout into confirmed signup. Embedded automatic loading starts this third-party code before marketing consent; choose the loading policy and disclosures appropriate to your site.
Use production HTTPS and review hosting security headers for the actual script, connection and verification destinations. Forma's build generates a CSP from the active collection modes: preview adds no external Kit destinations; active Kit modes add supported provider handler/Form origins; endpoint mode adds its receiving origin to form-action. The standard embed receives path-limited reCAPTCHA permissions; enabled native Forms receive them when their copied reCAPTCHA setting is true. Custom provider fonts, analytics and other additions need deliberate extra origins rather than an automatic allowance. Rebuild after changing these settings and run npm run security:check. The local production preview checks requested HTML against the manifest and enforces its generated policy, while your production host must apply its headers separately. Follow HSTS and Content Security Policy.
If a provider introduces another required destination, inspect the actual browser violation and the provider's current guidance. Add only the reviewed exact HTTPS origin to the relevant additionalSources array in src/config/security.ts, rebuild and retest. Do not use broad wildcards or script unsafe-inline/unsafe-eval to make an error disappear. Passing CSP only means the browser permits a request; it does not prove acceptance, confirmation, delivery, provider approval or sufficient abuse protection. If you choose a custom endpoint, its server validation, abuse protection, applicable request protections and secure record handling are your responsibility; no such backend is included.
Optional: support Forma's development
Kit is an optional provider, not a requirement or a service included in your Forma purchase. We may earn a commission on qualifying paid purchases made through our referral link. Using it is optional, helps support ongoing improvements to Forma, and does not affect your included Forma features or support.
Explore Kit — optional affiliate link
Go directly to Kit pricing — non-affiliate link
As checked on 16 October 2026, Kit's free plan advertises up to 10,000 subscribers, unlimited signup forms and unlimited email broadcasts. Paid plans offer additional capabilities, such as unlimited automations and email sequences. Review the current plans and conditions before choosing; provider allowances and pricing can change. Signing up through either link is your choice.
These links are for the template buyer setting up an email service. Forma does not insert Kitee's affiliate links into your public newsletter, customer website or getting-started dialog. Your visitors subscribe to your list; they do not need their own Kit account. A direct link does not guarantee removal of any referral tracking from an earlier visit.
1. Create your own inline Kit Form
In your Kit account, open Grow → Landing Pages & Forms (the navigation may call this Audience growth), choose Create a form, select Inline, then choose an Inline template. Some accounts may show + New → Form instead. Clare is one template you can use; Forma does not require it. Customize the heading, email label, button, colors and privacy link, then use Save & Publish. Settings dialogs also have their own Save control; publish the Form after saving your changes. A Kit Landing Page takes over its own page; it is not the embeddable Form required here. See Kit's Form builder guide.
Both primary and secondary Kit settings must be filled in. Use one Form for each language when you need translated provider fields and messages. You may deliberately paste the same Form's exact UID/script/share values into both slots if identical provider copy is suitable; switching Forma's language will not translate that Form. The slots refer to Forma's stable language positions, not literal en and el keys. If you replace Greek with German, update the secondary Kit Form too.
Keep the Form's design simple. Match Forma's colors and rounded fields using Kit's Form design settings. Forma styles the surrounding section; Kit supplies the embedded fields and their validation/messages. Review both themes because a third-party Form may use fixed colors of its own.
Optional Clare styling example
The following CSS was checked with Kit's Clare Inline Form during Forma's integration test on 16 October 2026. It gives the embedded form a fixed cream background, dark text and a violet button, so the form remains readable inside either Forma theme. It does not automatically switch the provider's colors when Forma switches themes. Other Kit templates or later builder versions may use different markup; inspect and test your own published Form before using the selectors unchanged.
In the Kit builder, open General styles → Custom CSS and paste the example below. In the tested builder, Kit automatically adds the Form's UID selector to each rule. Use these child selectors as shown; do not add another .formkit-form[data-uid="..."] prefix yourself. Edit the colors if needed, then recheck contrast and focus.
[data-style='clean'] {
background: #f7f8f2;
color: #1b201b;
border: 1px solid #d8ddcf;
border-radius: 14px;
padding: 20px;
box-sizing: border-box;
width: 100%;
}
.formkit-input {
border-radius: 10px !important;
color: #1b201b !important;
background: #fff !important;
}
.formkit-submit {
background: #b8a4ff !important;
color: #191620 !important;
border-radius: 10px !important;
font-weight: 600 !important;
}
.formkit-input:focus-visible,
.formkit-submit:focus-visible,
input[type='checkbox']:focus-visible {
outline: 2px solid #7560be !important;
outline-offset: 3px;
}
[data-group='checkbox'] input[type='checkbox'] {
display: inline-block !important;
width: 18px;
height: 18px;
margin: 0 8px 0 0;
vertical-align: middle;
accent-color: #7560be;
}
[data-group='checkbox'] label {
padding-left: 0 !important;
display: inline !important;
}
[data-group='checkbox'] label::before,
[data-group='checkbox'] label::after {
display: none !important;
}
The checkbox rules show the provider's actual checkbox and hide its duplicate decorative label mark in the tested Clare markup. They do not create a consent field or make it required; configure the choice in Kit as described below. After publishing, use Tab to reach the checkbox and Space to toggle it. Confirm that its label, checked state and focus remain usable, then check empty/invalid input, both themes, a narrow phone view and popup scrolling. Do not assume a visual correction establishes complete keyboard or screen-reader support for a different provider template.
Check the embedded result after publishing. Kit may warn that changes take a few minutes to appear, and an existing browser context may still show the older embed. Save and publish, allow the provider's stated update time, reload Forma and, if using kitLoad: 'interaction', choose Load again. Compare a fresh browser context if the builder and embed disagree. Seeing the new builder preview alone does not prove your visitors receive the same CSS. A provider-only style edit to the same JavaScript Form needs no Forma rebuild when its resource origins are already permitted. A new external font, image or other destination needs a reviewed CSP allowance and rebuild; follow Security and data flow.
2. Configure consent and confirmation in Kit
Configure the permission tag and its wording inside the Kit Form. Embedded mode displays that provider checkbox. Native mode deliberately renders the matching checkbox in Forma and submits its issued numeric tag only when selected; do not add an unrelated checkbox that is disconnected from provider records. For the tagged choice:
- Click the + below the Form's fields to add a field, then select it.
- In the sidebar, select Save as → Tag, then choose Checkboxes.
- Add a single consent tag, for example
Newsletter consent — 2026-01, and give its displayed label your accurate consent statement. - Leave the choice unchecked initially, save and publish, then verify its tag/status in your own account during testing.
See Kit's checkbox and tag guide. Kit also offers account-level consent settings. Do not assume an unchecked Kit choice blocks signup: its built-in consent flow can deliver an incentive without adding the marketing-consent tag. For the tagged approach, send marketing only to active, confirmed subscribers with the appropriate permission tag; review the actual Form's behavior and audience filters. A tag can remain after someone unsubscribes, so tag membership alone is not permission to send. This differs from Forma's required newsletter checkbox in native Kit and endpoint modes; marketing during demo access remains optional. Kit's consent-feature guide describes that distinction.
Keep a versioned copy of the exact wording you publish, for example newsletter-2026-01, together with its Form identity and publication dates. siteSettings.newsletter.consentVersion labels Forma's configured notice and formId identifies its configured source. Neither value is automatically submitted to a Kit-managed Form. Their automatic hidden fields apply only to endpoint mode. Configure any required source/notice tag, custom field and historical record in Kit or your own system deliberately.
For double opt-in, open Settings → Confirmation email, enable Send confirmation email and leave Auto-confirm new subscribers unchecked. Customize the sender, message and confirmation destination, save and publish. This adds email confirmation; it is distinct from the visitor's marketing-consent choice. The tested Settings dialog also had General, Domain name and Advanced tabs; provider labels can change. See Kit's confirmation email guide.
Before testing delivery, confirm your Kit account is approved to send. Review the confirmation's custom-domain sender, working unsubscribe link and required physical-address footer. These are provider settings; Forma does not supply or configure them. See Kit's confirmation-delivery troubleshooting.
Do not treat a tag or a frontend checkbox as an immutable audit ledger. Kit manages subscriber status and the fields/tags you configure. You remain responsible for the records you need, accurate notices, retention, access and handling withdrawals. The template does not certify legal compliance.
Return visitors and redirect settings
In the Form's Settings → Advanced, set Change what's shown to return visitors to Continue to show the form (the wording may vary slightly), save, and use Save & Publish. Use this setting for both Forma placements. Forma recognizes successful loading when an actual Form appears; Kit's Hide Form or custom-text alternatives can leave it waiting and eventually show a timeout to an existing subscriber.
Keep Send subscriber data to thank you page unchecked unless you deliberately need that behavior. Kit can otherwise add subscriber details, including an email address, to the redirect URL. Set a normal success message or your intended destination under General, and review the separate confirmation destination too. See Kit's Form settings.
3. Copy the Kit-issued embed values
After Save & Publish, open the Form's Embed menu and choose JavaScript, the embedding option Kit recommends. Copy the UID and src URL from the generated script. In the same menu, choose Share and copy the Form's direct URL as a fallback. See Kit's embedding guide.
You are looking for the two attributes in your own generated code:
<script async data-uid="YOUR_KIT_FORM_UID" src="YOUR_KIT_FORM_SCRIPT_URL"></script>
Do not paste that tag into a React component. Make these changes in one place:
- Open
src/config/site.tsin the buyer'ssource/folder, beside the other configuration files. - Find the existing
newsletter: { ... }block near the end ofsiteSettings. - Replace its existing
mode,placement,privacyPolicyHref,consentVersion,formIdandkitvalues using the example below. Keep the existingendpointblock and its field mappings. Do not add a secondnewsletterobject or replace the wholesiteSettingsobject. - Replace every uppercase placeholder with the exact value copied from your published Form. Use your actual working privacy-policy URL, an identifier for your signup source and a version for the notice wording you retain.
This example is the editable part of that existing object, not a complete site.ts file:
mode: 'kit',
placement: 'section', // Use 'dialog' for the newsletter popup.
privacyPolicyHref: 'https://www.your-domain.example/privacy/',
consentVersion: 'newsletter-2026-01',
formId: 'product-updates',
kit: {
primary: {
uid: 'YOUR_PRIMARY_FORM_UID',
scriptUrl: 'YOUR_PRIMARY_KIT_SCRIPT_URL',
shareUrl: 'YOUR_PRIMARY_KIT_SHARE_URL',
},
secondary: {
uid: 'YOUR_SECONDARY_FORM_UID',
scriptUrl: 'YOUR_SECONDARY_KIT_SCRIPT_URL',
shareUrl: 'YOUR_SECONDARY_KIT_SHARE_URL',
},
},
primary and secondary are the stable language slots, not language-code keys. For a first test you may copy the same published Form values into both slots deliberately; its provider text stays in that Form's language on both pages. Configure a separately translated Kit Form for the other slot when needed. No Kit API key, password or private token is needed or permitted in this public configuration. Kit's account/API/MCP tools are separate from this public Form embed and are not required by Forma.
Forma deliberately limits script URLs to HTTPS on kit.com, ck.page, convertkit.com or their subdomains, with the exact path /<uid>/index.js matching the configured UID. Extra query strings, fragments, credentials and custom ports are not accepted. Copy the complete generated URL without reconstructing it from a Form number, tracking URL or API address. If Kit supplies a different embed format, keep preview mode and request a reviewed integration update rather than disabling validation.
The share destination is optional for the Kit-designed embed: leave shareUrl: '' to omit it, or supply the real complete HTTPS Share URL, including a custom domain when Kit provides one. Native signup requires this hosted fallback. A relative path or HTTP address is not accepted for this fallback. The separate newsletter.privacyPolicyHref accepts a real HTTPS URL or a same-origin path starting with one /, such as /privacy/; that page must actually exist on your host. Loopback HTTP addresses are allowed only for local testing. Read any reported validation error rather than disabling its checks.
Set the cookie manager's separate cookieSettings.privacyPolicyHref in src/config/cookies.ts to your accurate policy too if you want its banner/dialog to link there. Forma does not create the policy page automatically.
4. Review loading and updates
In embedded kit mode, the default kitLoad: 'automatic' loads Kit when the section mounts on the page or the newsletter popup first opens. No Load or ready button appears. A short loading status remains until the actual Form renders. Kit supplies its own fields, validation and consent controls; configure them in Kit. Automatic loading can start provider requests/storage before a subscription choice, so describe and assess it for your actual site.
For an optional loading gate, set kitLoad: 'interaction'. Visitors then explicitly choose Load signup form; that control disappears once an actual Form renders. The accessible ready status remains. If focus is still on the disappearing Load control, it moves into the Form; focus that moved elsewhere is preserved. This loading choice is separate from marketing consent. A failed embed offers retry and the configured hosted fallback. Native kit-native fields are visible immediately and load the handler only on a valid, consented submission; kitLoad does not change native behavior.
Kit's JavaScript embed reflects edits published in its builder without a Forma rebuild when its identity is unchanged and the required resource origins remain permitted by CSP. If an edit introduces another external destination, update the relevant additionalSources setting, rebuild and retest. Allow provider publication/cache time and compare a fresh browser context. Native Forma fields, labels, notices and mappings instead come from your own source and need a rebuild after edits. Provider confirmation/settings still need publication in Kit. Raw HTML copies do not automatically synchronize your frontend fields.
Forma's cookie manager covers only optional theme/language preferences. Allowing preferences does not grant marketing permission; withdrawing them does not unload Kit, cancel a request or unsubscribe. Use the provider's withdrawal route. An ad blocker, network failure or content-security policy may prevent the connection. Test the hosted fallback separately. See Cookies.
5. Test the complete Kit journey
Build and inspect the production output. The delivered template is not connected to a buyer account. Keep preview mode until your own Forms and notices are ready; then perform the following account checks. Use an email address you own; do not submit someone else's details as a test.
- Verify the configured loading behavior: automatic embed loads on mount; interaction embed waits for Load; native forms show immediately and load no Kit handler before a valid, consented submit.
- Inspect fields, initially unchecked consent, privacy links, keyboard focus, translations and phone layout. No ready button should remain. For an interaction embed, check conditional focus transfer after Load. Check the actual checkbox with Tab and Space.
- Check empty/invalid input handling and the behavior with consent unselected. Verify the actual permission tag/status and confirm your marketing audience excludes addresses without the relevant permission; a Kit signup may still be accepted.
- Submit your own test address, confirm the provider's response, receive the confirmation email and follow its link.
- In Kit, verify that the correct Form, language-specific copy, confirmed subscriber status and configured consent tag/field match your test. Confirm the intended audience filter requires both confirmation and the relevant permission.
- Test the email's unsubscribe/profile-preference route. Confirm the provider stops the relevant sending and update any additional records you maintain. Check subscriber status as well as tags: an unsubscribed address may retain its consent tag, so your sending audience must not rely on that tag alone.
- For the Kit-designed embed, edit a harmless Form label or style in Kit, publish it, allow its stated update time and reload. With interaction loading, choose Load signup form again. Use a fresh browser context if the embed still shows an older version. Confirm the new provider label/style appears without changing Forma's source. Native Forma fields instead require editing the dictionaries and rebuilding.
- Test the direct share link and blocked-script fallback. Repeat on both language pages and in both appearances.
- After subscribing, revisit and reload in the same browser. With the documented Advanced setting, the actual Form should remain available after loading, without a false timeout. Also test a fresh browser context so Kit's returning-visitor storage does not conceal a setup problem.
For repeated delivery tests, Kit may throttle repeat confirmations to the same subscriber; its troubleshooting guide describes a 12-hour limit. A different Form or subscriber state can behave differently, so inspect the actual sending history. Use another address or alias you own when needed, and check spam/promotions plus the subscriber's sending history before treating a missing repeat email as a Forma error. See the confirmation-delivery checklist for current provider behavior.
When using placement: 'dialog', test exact #newsletter signup actions (set the header link to that destination if wanted), Tab/Shift+Tab through the loaded fields, the close button, Escape and return focus. Confirm the popup scrolls on a phone or at 200% zoom. Without switching the shared dialog to demo access, enter an address you own without submitting, close and reopen: the same Form and unfinished input should remain, with no second embed or extra Load signup form step. Refresh the page to confirm Forma's interface starts fresh. Check this against your own published Kit Form too, since the provider controls its fields and response states. A real subscription still needs the confirmation and provider-account checks above.
Kit offers subscriber CSV exports, including status, tags and custom fields. Protect exported personal data and choose an appropriate backup/retention process. An export is not automatically a complete consent history.
Alternative: connect your own endpoint
Use mode: 'endpoint' for a compatible receiving service or backend that accepts an ordinary HTML form POST. This keeps the visible fields in Forma's style, without loading Kit JavaScript. It is a separate integration, not a frontend substitute for Kit's API.
This mode does not provide a ready-made adapter for every email platform. A destination that requires a private API key, custom authorization header or JSON API request needs a suitable receiver on your own backend. For Kit, use mode: 'kit' or mode: 'kit-native' with the appropriate public Form settings; do not paste an account API URL into endpoint.url and expect the same result.
Edit the existing endpoint fields in siteSettings.newsletter:
mode: 'endpoint',
placement: 'section', // 'dialog' uses the same form inside the signup popup.
privacyPolicyHref: 'https://www.your-domain.example/privacy/',
consentVersion: 'newsletter-2026-01',
formId: 'product-updates',
endpoint: {
url: 'https://forms.your-domain.example/subscribe',
emailField: 'email',
consentField: 'marketingConsent',
noticeVersionField: 'consentVersion',
languageField: 'language',
sourceField: 'formId',
},
The URL above is an illustration, not a working service. Use a public HTTPS receiver or a same-origin path starting with one /, such as /subscribe/. A relative receiver path still requires a working backend or host proxy at that route; Forma's static export does not create one. HTTP is accepted only for loopback testing (localhost, 127.0.0.1 or [::1]), never as a public production receiver. The privacy-policy destination may also be a real HTTPS URL or same-origin path.
Set all five field names to the names your receiver expects. Each must be different, start with an ASCII letter (A–Z or a–z), and then use only ASCII letters, digits, _, . or -. For example, marketingConsent is accepted and email[] is rejected. A service that requires another naming scheme needs an adapter on your own backend.
These fields submit the email, the checked choice true, notice version, current configured language code and form/source identifier. The checkbox is required and unchecked initially. Its visible wording comes from the current content file's newsletter fields.
Submission navigates to the receiving endpoint. It uses a standard encoded form POST, not a JavaScript JSON request. The receiving service must accept that format and return an appropriate success, error or redirect page. Forma does not claim success before the receiver responds and does not save a copy of the address or consent in browser storage.
With JavaScript, the form uses the translated inline validation described above before allowing a valid POST. Without JavaScript, its required email and checkbox constraints and ordinary POST remain available through the browser. Recheck both paths with your receiver; frontend validation does not replace server-side validation.
Your receiver must: validate the email and explicit choice, verify the permitted notice version/source, add its own trustworthy receipt timestamp, apply abuse protection, store and protect records, handle duplicate requests and failures, and provide withdrawals/unsubscribe. Hidden frontend fields are editable by a visitor; they are not trusted evidence on their own. If using double opt-in, the receiver handles confirmation and status separately.
Keep API credentials and private webhook URLs on your backend. Do not paste a private Zapier Catch Hook into public Forma configuration. Use a suitable public form service or your backend to forward accepted records to Zapier or another automation tool. No backend code, database schema, record viewer or delivery automation is included.
Test demo access separately
With demoAccess.mode: 'kit', use an owned test address. First submit valid name/email with marketing unchecked: the demo continuation must appear without a signup request. Then reopen and submit with permission selected: demo access must remain available while Kit responds, and the correct separate Form, name, tag, confirmation and unsubscribe must be verified. Test failure/unknown results, a provider verification step, repeated open/close, Escape, focus return and both languages/themes. No fake subscription confirmation should appear. Do not count a received request as confirmed signup or report untested provider challenges as passed.
Keep the newsletter optional
Set mode: 'disabled' when you do not collect subscribers. Remove or redirect navigation/CTA links to the hidden signup and choose normal signup/checkout links if that is your conversion flow. Keep the supplied preview mode for an explicitly non-collecting demonstration.
After configuration changes, run npm run format, review the result, then npm run check. Rebuild after editing source settings; changes to site.ts do not rewrite an existing static export. Use Troubleshooting for configuration errors and Support for included-template questions. Your provider account, campaigns and receiving backend remain your responsibility.