Having a separate SeaText account for Square means using a distinct login and subscription dedicated solely to managing Square integrations. Instead of grouping all your marketing efforts under one roof, a separate account allows you to treat the integration as an independent entity. This is often done by businesses that need to keep financial data or performance metrics strictly partitioned between different business units.

Choose a single SeaText account if you run one primary store and want to keep your workflow simple. Choose a separate SeaText account if you are managing multiple distinct brands, development vs. production environments, or need to isolate the billing for different Square locations.

Understanding the separate account concept

At its core, a separate account is a structural choice where one SeaText subscription is tied to one specific URL or Square integration. While SeaText allows you to manage multiple locations under one account, there are technical and organizational scenarios where a split is necessary. This is not about the features available, but about how the data is processed and billed.

The primary reason for this separation is security and organization. If you are testing a development domain alongside your production domain, using separate accounts ensures that your testing data does not interfere with your live conversion metrics. It also prevents a situation where a change in one integration accidentally affects the AI parameters of another.

Each SeaText account is linked to a single primary URL. This means the AI agent tracks and serves traffic only for that specific domain. If you need to use SeaText on multiple distinct domains, you must create separate accounts for each one. This ensures the AI correctly attributes visits and optimizes copy for each source.

Why do businesses choose separate accounts?

The most common reason to use a separate account is for multi-domain strategies. If you operate two different websites that use Square but target entirely different audiences, separate accounts allow you to tune the AI agents specifically for each audience. This includes different language settings, copy tones, and localized content strategies.

Another factor is financial reporting. Large organizations often have different departments funding different marketing campaigns. A separate SeaText account allows each department to pay its own subscription and track its own ROI directly. This simplifies accounting by removing the need to manually split costs from a single master invoice.

Data isolation is also critical for compliance. If one business unit handles sensitive financial data, a separate account prevents that data from mixing with other units. This can be essential for audits or regulatory requirements.

Finally, separate accounts allow for independent AI customization. Each account can have its own AI parameters, such as tone of voice or target keywords. This means you can optimize the AI for each brand without affecting others.

How the integration process works

Setting up a separate account follows the standard integration path but starts with a new registration. You create the SeaText account using a unique email address. Once logged in, you navigate to the integrations section and follow the OAuth flow to link your Square store.

After the link is established, you must install the provided JavaScript code on your target domain. The script remains inert until you activate it within the SeaText dashboard. To verify the connection, you visit your website and refresh the page. If your website name appears next to the SeaText logo, the account is active and ready to process traffic.

Important: Wait at least five minutes until you see your website name displayed next to the SeaText logo at the top of the page. This indicates that your website is connected and ready to proceed. If you do not see it after ten minutes, contact support. This could indicate an issue during installation.

Once connected, you can activate the AI agents you need. Navigate to the Main AI Hub and turn on the agents for your Square integration. You can then configure AI parameters such as copy tone, target languages, and testing rules.

Key trade-offs between isolation and simplicity

While separate accounts offer total isolation, they come with administrative overhead. You must log in to multiple dashboards to check performance or update settings. If you have five small stores, managing five separate accounts might feel like unnecessary work compared to a single unified view.

Conversely, the risk of a single account is data overlap. In a shared environment, a global change to an AI parameter might impact all connected sites simultaneously. Separate accounts provide a "sandbox" feel, ensuring that an experiment or a configuration on one Square integration has zero impact on the stability of the others.

Cost is another trade-off. Each separate account requires its own subscription. If you have multiple accounts, you pay for each one individually. This can increase your monthly expenses compared to a single account that covers multiple locations.

However, the benefits often outweigh the costs for complex setups. For example, if you run a development site and a production site, separate accounts prevent test data from corrupting live metrics. This is crucial for accurate performance tracking.

Another practical scenario is managing multiple brands. If each brand has its own Square integration, separate accounts allow you to tailor the AI for each brand's unique audience. This can lead to higher conversion rates and better customer experiences.

Limitations and restrictions

There are specific technical limitations to consider when setting up accounts. For instance, development URLs, such as localhost, are often restricted for security reasons. You must use a valid, real domain for the AI to function correctly. Dynamic domains may also not function properly because SeaText might be unable to reliably associate traffic with your specific account.

Additionally, one SeaText AI account is linked to a single primary URL. If you need to use the service on multiple distinct domains, the system requires you to create separate accounts for each domain to ensure the AI correctly tracks and serves traffic for each specific source.

There is also a limit on the number of locations you can manage under one account. While SeaText supports multiple Square locations, each location may require its own connection settings. If you have many locations, separate accounts might be necessary to avoid configuration conflicts.

Another limitation is that you cannot merge separate accounts later. Once you create separate accounts, you cannot combine them into one. This means you must plan your account structure carefully from the start.

Finally, support and troubleshooting can be more complex with multiple accounts. If an issue arises, you may need to identify which account is affected and provide specific details. This can slow down resolution times.

Frequently asked questions

Do I need a new SeaText account for every Square location?

No, you can manage multiple locations under one SeaText account, but each location may require its own connection settings to ensure accuracy.

Can I use the same login for multiple stores?

Yes, you can use the same SeaText login to integrate multiple stores, but each store requires its own separate settings to avoid data overlap.

What if I don't see my website name in the header?

Wait at least five minutes for the website name to display. If it does not appear after ten minutes, contact the support team as this may indicate an installation issue on your platform.

Is having a separate account more expensive?

The cost depends on the subscription plan chosen for each account. Since each account is a separate subscription, you would pay for each individual instance independently.

Can I use a separate account for a development site?

No, development URLs like localhost are restricted for security reasons. You must use a valid, real domain for the AI to function properly.

How do I decide between a single and separate account?

Consider your needs for data isolation, billing separation, and AI customization. If you have multiple distinct brands or environments, separate accounts are better. For simple setups, a single account is easier.

Can I switch from a single account to separate accounts later?

Yes, you can create new separate accounts and migrate your integrations. However, you cannot merge separate accounts into one later. Plan ahead.

Does a separate account affect AI performance?

No, each account operates independently. The AI performance depends on your configuration and traffic, not on the number of accounts.

Understanding the Square-SeaText Integration

Connecting your Square account to SeaText is a strategic move to streamline your business operations. This integration allows you to sync transaction data, customer information, and product lists directly into your SeaText dashboard. Instead of manually exporting CSV files, the system handles data flow automatically. This ensures your marketing analytics are always up to date.

The primary benefit of this connection is the elimination of data silos. When a sale occurs in Square, the data is reflected in SeaText instantly. This is particularly useful for businesses running marketing campaigns that need to see real ROI. You can track which ads led to actual Square purchases without manual entry errors.

Many users worry that they need a new account to use integrations. This is incorrect. The platform is designed to work with your existing profile. By linking your current account, you maintain all your history, settings, and data. The process is secure and uses industry-standard protocols.

What You Need Before You Start

Before you begin the connection process, ensure you have the following ready to avoid interruptions. Having these prepared prevents errors during the authorization phase.

• An active SeaText account: You must have a valid login. If you do not have one, create it at seatext.com.
• Square account credentials: You need the email address and password for your Square merchant account.
• Admin access: You must have administrative privileges on both SeaText and Square to grant data permissions.
• A modern web browser: Use Chrome, Firefox, or Edge to ensure the redirect works correctly.

Remember, you do not need a separate SeaText account for Square. The integration is built to enhance your existing account capabilities.

Step-by-Step Guide to Connecting Square

Step 1: Log In to Your SeaText Account

Start by navigating to seatext.com. Enter your current username and password. If you are already logged in, you will land directly on your own. If your session has expired, log in fresh.

Step 2: Open the Integrations Section

Once on the dashboard, look at the main navigation menu. Search for 'Integrations' or 'Connected Apps.' This is typically located within the 'Settings' or 'Account' dropdown tabs. Clicking this will open a gallery of all supported third-party services.

Step 3: Find Square in the Integration List

Browse the list of available apps. You might find Square categorized under 'Payment Processors' or 'POS Systems.' Once you locate the Square icon, click the 'Connect' or 'Add' button next to it.

Step 4: Authorize the Connection via OAuth

SeaText will now redirect you to a secure Square login page. Enter your Square credentials here. Square will ask for your permission to allow SeaText to access your data. This uses the OAuth flow. This means SeaText never sees or stores your Square password. It only receives a secure digital token to fetch the necessary data.

Step 5: Confirm the Connection

After you click 'Allow,' Square will automatically redirect you back to the SeaText platform. Look for a success message at the top of the screen. This confirms the link is active. Your existing account is now officially synced.

Step 6: Test the Integration

To ensure everything is working perfectly, perform a small test. Try to sync a single product or view your recent Square transactions within the SeaText interface. If the data appears, the connection is successful. If it remains empty, verify that you granted all requested permissions during the OAuth step.

Why This Integration Matters for Your Growth

The connection goes beyond simple data syncing. It is about data-driven decision making. When your Square data lives inside SeaText, you can perform advanced customer segmentation. You can identify your highest-value customers based on actual purchase history. This allows for highly targeted email campaigns.

Furthermore, it helps inventory management. If you update a product price in Square, those changes can be reflected in your marketing materials. This prevents you from promoting products at outdated prices or incorrect stock. It creates a single source of truth for your entire business operation.

For small businesses, the time saved is significant. Manual data entry is prone to human error and takes hours. Automation frees you to focus on customer service and product development. The integration pays for itself in saved labor hours and better data accuracy.

Common Mistakes and Troubleshooting

Even simple processes can have hurdles. If you see an error during the OAuth step, check these common issues:

• Clear browser cache: Old site data can interfere with redirects. Clear your cache and cookies, then restart.
• Account verification: Ensure you are logging into the correct Square account that holds the data you want to sync.
• Account status: Check that your Square account is active and not restricted for security reasons.
• Pop-up blockers: Sometimes browser extensions block the Square login window from opening. Try disabling them temporarily during the process.

The most common mistake is trying to create a second SeaText account for Square. This creates duplicate data and causes the API to fail to find your primary record. Always stick to your primary existing account.

Key Facts About the Square-SeaText Integration

Limitations and When This Advice Not Apply

This guide assumes you are using the standard versions of both SeaText and Square. If you use enterprise-level versions of either service, the interface may look different. Additionally, the platform does not support connecting multiple Square accounts to a single SeaText account. If you manage multiple stores with different Square accounts, you must use separate SeaText accounts for each one.

Frequently Asked Questions

Do I need a Square account to use SeaText?

No. SeaText works perfectly without Square. The integration is an optional feature that adds specific payment processing analytics.

Can I connect Square to SeaText without admin access?

No. You must have administrative rights in both accounts to authorize the data transfer.

Will connecting Square affect my existing SeaText data?

No. The integration only adds Square-related data. It does not delete or modify your existing site content.

How do I disconnect Square from SeaText?

Go to the Integrations section in SeaText, find Square, and click 'Disconnect.' You can also revoke access directly from your Square account settings.

What if I change my Square account password?

The OAuth token remains valid. You do not need to reconnect unless you manually revoke the token from your Square settings.

Is the connection secure?

Yes. SeaText uses OAuth 2.0, which ensures your Square password is never shared with SeaText. The entire connection tunnel is encrypted.

Prerequisites for Testing Recurring Payments

Before you start testing, you need a Square Developer account and a sandbox environment. The sandbox mimics the live Square API but uses fake money and test card numbers. You also need a test customer profile and a saved card on file (a card ID) to create a subscription.

• Square Developer Account – Sign up at developer.squareup.com. Your sandbox credentials are separate from your production credentials.
• Sandbox Environment – In the Square Developer Dashboard, enable sandbox mode. All API calls to the sandbox endpoint (https://connect.squareupsandbox.com) will not affect real payments.
• Test Card Numbers – Square provides specific card numbers for sandbox testing. For example, use 4111 1111 1111 1111 for a successful payment and 4000 0000 0000 0002 for a declined payment.
• API Credentials – Generate a sandbox access token from the Developer Dashboard. Keep this token secret.

Step 1: Create a Test Customer and Save a Card on File

Recurring payments require a customer profile with a saved card. Use the Customers API to create a test customer in sandbox mode. Then use the Cards API to save a test card to that customer. The response will include a card_id that you use when creating the subscription.

Example API call (simplified):

POST /v2/customers
{"given_name": "Test", "family_name": "User", "email": "test@example.com"}

POST /v2/cards
{"card_nonce": "cnon:test-nonce-ok", "customer_id": "CUSTOMER_ID"}

Square sandbox accepts the nonce cnon:test-nonce-ok to simulate a valid card. The response returns a card_id.

Step 2: Create a Subscription Plan (Catalog Object)

Subscriptions in Square are linked to a subscription plan defined in the Catalog API. Create a plan with a price, billing frequency (e.g., monthly), and a trial period if needed. Use the Catalog API to create a SUBSCRIPTION_PLAN object.

Example plan creation:

POST /v2/catalog/object
{"type": "SUBSCRIPTION_PLAN", "id": "#plan", "subscription_plan_data": {"name": "Test Monthly Plan", "phases": [{"cadence": "MONTHLY", "periods": 12, "amount_money": {"amount": 1000, "currency": "USD"}}]}}

The response includes a plan_variation_id that you use to create the subscription.

Step 3: Create a Subscription

Now create a subscription for the test customer using the saved card and the plan variation ID. Use the Subscriptions API endpoint.

POST /v2/subscriptions
{"customer_id": "CUSTOMER_ID", "location_id": "LOCATION_ID", "plan_variation_id": "PLAN_VARIATION_ID", "card_id": "CARD_ID"}

If successful, the response includes a subscription_id and the status ACTIVE. The subscription will start immediately or on the specified start date.

Step 4: Trigger a Billing Cycle

Square subscriptions automatically bill on the schedule defined in the plan. To test a billing cycle without waiting, you can use the subscription/start or subscription/resume endpoints, or simply wait for the next scheduled charge. For faster testing, create a subscription with a short cadence (e.g., DAILY) or use the sandbox's ability to simulate time by adjusting the subscription's start date to the past.

Note: Square sandbox does not automatically advance time. You can manually trigger a charge by calling the charge endpoint with the card ID, but for true recurring testing, you may need to create a subscription and then use the subscription/event webhook to simulate a payment event.

Step 5: Verify the Payment and Subscription Status

After the billing cycle, check the subscription status using the Retrieve Subscription endpoint. The status should be ACTIVE if the payment succeeded, or PAST_DUE if it failed. Also verify that a payment object was created by calling the Payments API with the subscription ID or customer ID.

Verification checklist:

• Subscription status is ACTIVE after a successful charge.
• A payment record exists with the correct amount and currency.
• Webhook events (if configured) were sent to your endpoint.
• Test a failed payment by using a declined card number (e.g., 4000 0000 0000 0002) and confirm the subscription becomes PAST_DUE.

Testing Failed Payments and Retry Logic

Square automatically retries failed payments based on your account settings. In sandbox, you can simulate a failed payment by using a card that declines. After the first failure, the subscription status changes to PAST_DUE. Square will retry the payment after a few days. You can test the retry by calling the subscription/resume endpoint or by waiting for the automatic retry (which may not happen in sandbox). For thorough testing, manually trigger a retry using the charge endpoint with the same card ID.

Testing Webhooks for Recurring Payments

Webhooks are critical for automating responses to subscription events. Square sends webhook events for subscription.created, subscription.updated, payment.created, and payment.failed. To test webhooks:

1. Set up a webhook endpoint in your application (e.g., /webhook/square).
2. In the Square Developer Dashboard, add the endpoint URL under Webhooks.
3. Create a subscription or trigger a payment in sandbox.
4. Check your server logs to confirm the webhook payload was received.
5. Use a tool like webhook.site to capture and inspect the payload if your endpoint is not yet live.

Square sandbox sends real webhook events, so you can fully test your webhook handling logic.

Common Mistakes and How to Avoid Them

• Using production credentials in sandbox – Always double-check that your API calls go to connect.squareupsandbox.com and use a sandbox token.
• Not saving the card ID – You must save a card on file and use its ID when creating a subscription. A one-time nonce will not work for recurring payments.
• Forgetting to set a location ID – Subscriptions require a valid location ID. In sandbox, use the default location ID provided in your sandbox account.
• Ignoring webhook signatures – Square signs webhook payloads. Verify the signature in your endpoint to ensure the request is from Square.

Key Facts About Square Recurring Payments Testing

Limitations of Sandbox Testing

Square sandbox does not simulate all real-world scenarios. For example, it does not automatically advance time, so you cannot test a monthly subscription's second billing cycle without manual intervention. Also, sandbox does not support all payment methods (e.g., Afterpay, Cash App Pay) that may be available in production. Some webhook events may be delayed or not sent in sandbox. Always perform a final round of testing in production with a small amount of real money before going live.

Frequently Asked Questions

Can I test recurring payments without a real credit card?

Yes. Square sandbox provides test card numbers that simulate successful and failed payments. No real money is involved.

How do I simulate a failed recurring payment?

Use a test card number that Square designates for declines, such as 4000 0000 0000 0002. The subscription will become PAST_DUE.

Do I need to set up webhooks for testing?

Not strictly, but webhooks are essential for automating responses to subscription events. Testing webhooks in sandbox ensures your integration handles them correctly.

Can I test multiple subscriptions for the same customer?

Yes. A single customer can have multiple active subscriptions, each with a different plan or card.

How do I test subscription cancellation?

Use the Cancel Subscription endpoint. The subscription status changes to CANCELED and no further charges occur.

What happens if I use a production token in sandbox?

Your API call will fail with an authentication error. Always use the sandbox token for sandbox endpoints.

Is there a cost to use Square sandbox?

No. Square sandbox is free and does not charge any fees for test transactions.

Diagnostic Sequence: Step by Step

Follow this order to isolate the problem quickly. Do not skip steps.

1. Check your Square environment. Confirm you are sending requests to the sandbox base URL (https://connect.squareupsandbox.com) and not the production URL. A common mistake is using live credentials in sandbox or vice versa.
2. Verify your API credentials. Log in to the Square Developer Dashboard. Ensure your application has a valid Access Token for the sandbox environment. Tokens expire or can be revoked. Generate a new sandbox token if needed.
3. Use Square's test card numbers. Square provides specific test card numbers for different scenarios (e.g., success, decline, insufficient funds). Using a real card in sandbox will fail. Refer to Square's test values documentation for the correct numbers.
4. Inspect API response codes. Every Square API call returns an HTTP status code and a JSON body with error details. Look for codes like 400 BAD_REQUEST, 401 UNAUTHORIZED, or 404 NOT_FOUND. The error message often tells you exactly what is wrong (e.g., missing required field, invalid card data).
5. Check your webhook configuration. If your integration relies on webhooks (e.g., for payment notifications), ensure the endpoint URL is publicly accessible and returns a 200 OK response. Use a tool like webhook.site to inspect incoming payloads during testing.
6. Review your code for idempotency keys. Square requires an idempotency key for certain requests (like creating payments) to prevent duplicate charges. If you reuse a key across different requests, you will get a 409 CONFLICT error. Generate a unique key for each request.
7. Test with Square's API Explorer. The Square API Explorer lets you make live API calls from your browser. Use it to verify that your request payload is correct before running it from your code.

Common Causes of Test Failures

Incorrect Environment or Credentials

This is the most frequent issue. Developers accidentally use production tokens in sandbox or sandbox tokens in production. Double-check the base URL and token in your configuration file. Square sandbox tokens start with EAAA (sandbox) while production tokens start with EAAA as well but are tied to a live application. The easiest way to confirm is to make a simple ListLocations call and see if it returns test locations.

Invalid Test Card Data

Square's sandbox only accepts specific test card numbers. Using a random card number will result in a 400 BAD_REQUEST with an error like CARD_TOKEN_ISSUE. Always use the official test card numbers from Square's documentation. For example, 4111 1111 1111 1111 with any future expiry date and any CVV will simulate a successful payment.

Missing or Incorrect Idempotency Keys

Square enforces idempotency for payment and order creation requests. If you send the same request twice with the same idempotency key, Square returns the same response (no duplicate charge). But if you reuse a key for a different request, you get a 409 CONFLICT. Generate a new UUID for each unique request.

Webhook Endpoint Not Reachable

If your integration uses webhooks, the endpoint must be publicly accessible during testing. Localhost URLs (e.g., http://localhost:3000/webhook) will not work. Use a tunneling service like ngrok to expose your local server, or deploy to a staging environment. Square will retry failed webhook deliveries up to three times, but you should verify the endpoint responds with 200 OK within a few seconds.

API Rate Limits

Square applies rate limits to API calls. In sandbox, the limits are lower than production. If you make too many requests in a short period, you will receive a 429 TOO_MANY_REQUESTS error. Implement exponential backoff in your code to handle this gracefully.

Key Facts About Square Integration Testing

Limitations of Square Sandbox Testing

The sandbox environment is not identical to production. Some features are limited or behave differently:

• No real payment processing. You cannot test actual bank transfers or card network responses. All transactions are simulated.
• No real-time webhook delivery. Webhooks in sandbox may have delays or not fire at all for certain events. Use the Square Developer Dashboard to manually trigger webhook events for testing.
• Limited location data. Sandbox locations have dummy addresses and may not reflect your actual business setup.
• No refunds or disputes. You cannot test refund flows or chargeback handling in sandbox. Those require production testing with small amounts.

If your integration relies on these features, plan for additional testing in production with a small live transaction (e.g., $1.00) after sandbox validation passes.

Terminology You Should Know

• Access Token: A secret key that authenticates your API requests. Each Square application has separate tokens for sandbox and production.
• Idempotency Key: A unique string you send with each request to ensure Square processes it only once. Prevents duplicate charges.
• Webhook: An HTTP callback that Square sends to your server when an event occurs (e.g., payment completed).
• API Explorer: A web-based tool from Square that lets you test API calls interactively.
• Sandbox: A test environment that mimics Square's production API but uses fake data.

Frequently Asked Questions

Why do I get a 401 Unauthorized error in sandbox?

Your access token is likely invalid or belongs to a different Square application. Generate a new sandbox token from the Developer Dashboard and update your code.

Can I use my own credit card to test in sandbox?

No. Square's sandbox only accepts specific test card numbers. Using a real card will fail with a card error. Use the test numbers from Square's documentation.

How do I test webhooks locally?

Use a tunneling service like ngrok to expose your local server to the internet. Then set your webhook URL in the Square Developer Dashboard to the ngrok URL. Square will send events to that URL.

What does a 409 Conflict error mean?

You reused an idempotency key for a different request. Generate a new unique key (e.g., a UUID) for each API call that requires idempotency.

How long does it take for a sandbox webhook to arrive?

Webhooks in sandbox are not guaranteed to be real-time. They may arrive after a delay or not at all. Use the Developer Dashboard to manually trigger webhook events for reliable testing.

Can I test refunds in sandbox?

Yes, you can test refunds using the sandbox API. Use a test payment ID from a previous sandbox transaction. Refunds will be simulated and no real money moves.

What should I do if my integration works in sandbox but fails in production?

Check that you are using the production access token and base URL. Also verify that your production Square account is active and has the necessary permissions (e.g., payment processing enabled). Test with a small live transaction to isolate the issue.

Practical Scenarios and Decision Criteria

Understanding when to escalate or change your approach can save hours. Here are common scenarios and how to decide.

Scenario: You get a 400 error with "CARD_TOKEN_ISSUE"

This almost always means you used a real card number in sandbox. Switch to a test card from Square's list. If the error persists, check that the card data format matches Square's requirements (e.g., expiry as MM/YY, CVV as 3-4 digits).

Scenario: Webhooks never arrive

First, confirm your endpoint is publicly reachable. Use a tool like ngrok. Then, in the Square Developer Dashboard, go to Webhooks and click "Send test event." If the test fails, your endpoint may have a code error. Check server logs for incoming POST requests.

Scenario: Idempotency key errors on every request

You may be generating the same key for different requests. Ensure you create a new UUID per request. Some developers accidentally hardcode a static key. Use a library like uuid in Node.js or UUID.randomUUID() in Java.

Scenario: Rate limit errors during load testing

Sandbox rate limits are lower than production. If you are load testing, add delays between requests. Square recommends at least 1 second between calls. Use exponential backoff: wait 1 second, then 2, then 4, up to a maximum.

Why These Steps Matter

Each step in the diagnostic sequence targets a specific failure mode. Skipping steps leads to wasted time. For example, checking credentials first avoids debugging a correct code path with wrong tokens. Inspecting error codes gives you the exact problem, not a guess. Using test cards ensures you are not blocked by real card network rules. Webhook verification prevents silent failures where payments succeed but notifications never arrive. Idempotency keys protect against duplicate charges even in testing. The API Explorer confirms your payload structure before you write code. Together, these steps reduce debugging time from hours to minutes.

What Is Square Sandbox Mode?

Square Sandbox is a free, isolated test environment. It mimics Square's production APIs. You can simulate payments, orders, invoices, and other transactions. No real money is used. No real data is affected. You get a test seller account and test payment methods. The sandbox base URL is https://connect.squareupsandbox.com. Credentials and resources from the sandbox cannot be used in production. The reverse is also true. This separation keeps your live data safe.

Why does this matter? Developers need a safe place to test code. Without a sandbox, you risk charging real customers by mistake. You also risk corrupting your production database. Sandbox mode lets you experiment freely. You can try new features, debug errors, and train your team. All without financial risk.

Prerequisites

Before you start, you need:

• A Square Developer account. It is free to create at developer.squareup.com.
• An application registered in the Square Developer Console. Square provisions a sandbox environment for each application you register.
• Your sandbox API credentials: Application ID and Access Token. You can find these in the Developer Console under your app's credentials section.
• A test seller account. This is automatically created when you register an app.

These prerequisites are simple. Most developers can complete them in under 10 minutes. The sandbox is ready as soon as your app is created.

Step 1: Enable Sandbox Mode in the Developer Console

Log in to the Square Developer Console. Select your application. In the left menu, click Sandbox. Ensure the sandbox toggle is turned on. This activates the sandbox environment for your app. You can also manage test accounts from this page.

Enabling sandbox mode is a one-time setup. Once enabled, all API calls to the sandbox endpoint will use test data. You can toggle it off anytime. But for testing, keep it on.

Step 2: Get Your Sandbox Credentials

In the Developer Console, go to Credentials. Copy your Application ID and Access Token for the sandbox environment. These are different from your production credentials. Use these in your API calls to authenticate against the sandbox endpoint.

Why separate credentials? Security. If you accidentally expose your production token, someone could charge real cards. Sandbox tokens are harmless. They only work in the sandbox. Store them safely anyway. Treat them like real secrets in your code.

Step 3: Use the Correct Sandbox Endpoint

All API calls must go to the sandbox base URL: https://connect.squareupsandbox.com. For example, to create a payment, use https://connect.squareupsandbox.com/v2/payments. For OAuth, use https://connect.squareupsandbox.com/oauth2/token. Never use the production URL (https://connect.squareup.com) during sandbox testing.

This is a common mistake. Developers copy code from production and forget to change the URL. The result is a failed request or, worse, a real charge. Always double-check your endpoint. Use environment variables to store the base URL. That way, you can switch between sandbox and production with a single config change.

Step 4: Choose a Test Payment Method

Square provides test credit card numbers that return predictable results. You can use these to generate one-time-use payment tokens via the Web Payments SDK or In-App Payments SDK. Alternatively, you can use test source IDs directly in the CreatePayment API call. The sandbox does not accept real credit cards.

Test Credit Card Numbers

Use any future expiration date (e.g., 12/25) and any 5-digit ZIP code (e.g., 94103). These test numbers are documented by Square. They never change. You can rely on them for consistent testing.

Step 5: Make a Test Payment API Call

Here is an example using cURL to create a payment of $10.00 (1000 cents) with a test source ID. Replace YOUR_ACCESS_TOKEN with your sandbox access token.

curl -X POST https://connect.squareupsandbox.com/v2/payments \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -d '{
    "source_id": "cnon:card-nonce-ok",
    "idempotency_key": "unique-key-123",
    "amount_money": {
      "amount": 1000,
      "currency": "USD"
    }
  }'

The source_id value cnon:card-nonce-ok is a test nonce that always succeeds. For a declined payment, use cnon:card-nonce-declined. The idempotency_key must be unique for each request to prevent duplicate charges.

Why use an idempotency key? Network errors can cause retries. Without a unique key, the same payment might be processed twice. The key ensures each request is processed only once. Generate a new UUID for every payment attempt.

Step 6: Verify the Payment in the Sandbox Dashboard

After a successful API call, log in to the Sandbox Square Dashboard (accessible from the Developer Console). Go to Transactions or Payments. You should see the test payment listed with the amount and status. This confirms the payment was processed correctly in the sandbox.

Verification is crucial. It confirms your integration works end-to-end. Check the status, amount, and currency. Also check the card brand and last four digits. If something looks wrong, debug your API call. The sandbox dashboard gives you full visibility.

Common Mistakes and How to Avoid Them

• Using production credentials in sandbox calls. Always double-check that your access token and application ID are from the sandbox environment.
• Using the production base URL. Ensure all API endpoints start with https://connect.squareupsandbox.com.
• Using a real credit card. The sandbox only accepts test card numbers. Real cards will be rejected.
• Not using a unique idempotency key. Reusing the same key for different requests can cause unexpected results.

These mistakes are easy to make. They are also easy to fix. Use environment variables. Write unit tests that check your endpoint URL. Always use test cards. Generate fresh idempotency keys. A little discipline saves hours of debugging.

Limitations of Square Sandbox

The sandbox does not support card-present (in-person) testing. It only simulates card-not-present transactions (online payments). Also, the sandbox does not process real payments, so you cannot test refunds to real cards. Some advanced features like chargebacks or disputes may not be fully simulated. For a complete list, refer to Square's sandbox documentation.

These limitations matter for planning. If your app uses Square Reader or Terminal, you need a different test approach. Square provides a separate test environment for in-person payments. Check their docs. Also, sandbox performance may differ from production. Do not use sandbox for load testing. It is not designed for high volume.

Frequently Asked Questions

Can I test recurring payments in sandbox mode?

Yes. You can create a card on file using test card numbers and then use that card for recurring charges. Use the CreateCard API with a test nonce, then call CreatePayment with the card ID.

How do I test declined payments?

Use a test card with CVV 222 or the test nonce cnon:card-nonce-declined. This will return a declined response from the sandbox.

Does sandbox mode cost anything?

No. Square Sandbox is free to use. You do not need a paid Square account to access it.

Can I test webhooks in sandbox mode?

Yes. You can configure webhook URLs in the Developer Console for your sandbox app. The sandbox will send webhook events for test transactions, allowing you to verify your webhook handler.

How do I reset my sandbox data?

You can reset your sandbox test account from the Developer Console. This clears all test transactions and data. You can also create multiple test accounts if needed.

What is the difference between sandbox and production?

Sandbox uses test data and fake payments. Production uses real data and real money. Credentials, endpoints, and accounts are completely separate. You cannot mix them.

Can I test Square APIs other than payments in sandbox?

Yes. The sandbox supports many Square APIs, including Orders, Catalog, Customers, and Invoices. Each API has its own test values and walkthroughs.

How do I test different currencies?

Set the currency field in your API request. The sandbox supports multiple currencies. Use USD, CAD, GBP, JPY, and others. The sandbox will process the payment in that currency. No real conversion happens.

Can I simulate a partial refund?

Yes. Use the RefundPayment API with a test payment ID. The sandbox will process the refund. You can refund the full amount or a partial amount. Check the sandbox dashboard to verify.

What happens if I exceed rate limits?

The sandbox has rate limits similar to production. If you exceed them, you get a 429 response. Wait and retry. This helps you test your rate limit handling code.

Symptoms of Integration Problems

You might see one of these signs:

• The SeaText AI script doesn't load on your Square site.
• Your website name doesn't appear in your SeaText account after installation.
• AI-generated content doesn't update or appears incorrectly.
• You get an error message when trying to activate the AI.

Diagnostic Sequence: Step by Step

Follow this order to find the cause. Do not skip steps.

Step 1: Verify Your Square Plan

Square offers different plans. Some lower-tier plans may not support third-party app integrations. Check your Square dashboard under Account & Settings > Business > Plan to confirm your plan allows external apps. If not, you may need to upgrade.

Step 2: Check Your SeaText Account and Script

Log into your SeaText AI account. Go to the integration page and copy the JavaScript code again. Make sure you have the correct code for your domain. Each SeaText account is linked to a single primary URL. If you use multiple domains, you need separate accounts.

Step 3: Install the Script Correctly on Square

In your Square Online site editor, go to Settings > Advanced > Code Injection. Paste the SeaText JavaScript code into the Header section. Save and publish your site. Visit your live site (not a preview) and stay on the page for at least 40 seconds. This activates the AI and links it to your account.

Step 4: Wait and Refresh

After installing, wait at least five minutes. Refresh your SeaText account page. Your website name should appear next to the SeaText logo at the top. If it doesn't show after 10 minutes, contact SeaText support.

Step 5: Clear Browser Cache

If the script is installed but nothing happens, clear your browser cache and cookies. Then revisit your Square site and the SeaText dashboard. Stale cache can prevent the AI from loading.

Technical Architecture of the SeaText JavaScript Injection

SeaText AI uses a JavaScript snippet injected into your Square site's header. This script runs when a visitor loads any page. It interacts with Square's DOM (Document Object Model) to read page content and visitor behavior.

The script creates a lightweight connection to SeaText's servers. It sends anonymized data about page elements, scroll depth, and dwell time. This data is used to generate AI content variants. The script does not modify your Square site's core files. It only adds a small, non-blocking script tag.

Square's Code Injection feature places the script in the section of every page. This ensures the script loads early. The script then waits for the DOM to be ready before activating. This prevents conflicts with Square's own JavaScript.

The script uses event listeners to track user interactions. It monitors clicks, scrolls, and time on page. It does not interfere with Square's checkout or payment processes. The AI remains inert until a visitor spends at least 40 seconds on the page. This ensures the AI only activates for genuine human visitors.

Security is built in. The script is served over HTTPS. It does not execute any code that could alter your Square store's functionality. It only reads content and sends data to SeaText's API. No content changes happen without your approval.

Advanced Debugging Using Browser Developer Tools

If the script doesn't load, use your browser's developer tools. Open the Network tab. Reload your Square site. Look for a request to seatext.com or a similar domain. If you don't see it, the script is not installed correctly.

Check the Console tab for errors. Common errors include "Failed to load resource" or "Script error." These indicate the script URL is wrong or blocked. Also look for "Content Security Policy" errors. Square may block external scripts if your plan restricts third-party content.

Use the Elements tab to verify the script tag is present. Search for "seatext" in the HTML. If the tag is missing, re-paste the code in Square's Code Injection. If the tag is present but the script doesn't run, check for JavaScript syntax errors in the Console.

Test with a private browsing window. This avoids cached scripts. If the script loads in private mode but not normal mode, clear your cache. Also disable browser extensions that block scripts, like ad blockers.

For advanced debugging, use the Sources tab. Set breakpoints in the SeaText script. Step through the code to see where it fails. This requires some JavaScript knowledge. Contact SeaText support if you need help.

Common Configuration Conflicts

Other third-party scripts can interfere with SeaText AI. For example, analytics scripts like Google Analytics or Facebook Pixel may conflict. They can cause race conditions where SeaText fails to load. To fix this, ensure SeaText's script is placed before other scripts in the header.

Square themes can also cause issues. Custom themes may modify the DOM in ways that break SeaText's event listeners. If you use a custom theme, test SeaText on a staging site first. Contact the theme developer for compatibility.

Content Security Policies (CSP) can block SeaText's script. Square's default CSP may not allow connections to seatext.com. Check your Square site's CSP headers. If they block external scripts, you need to add seatext.com to the allowed list. Contact Square support for help.

Ad blockers and privacy extensions can prevent the script from loading. These tools often block third-party scripts by default. Ask users to whitelist your site. Or use SeaText's server-side integration if available.

Multiple SeaText accounts on the same domain cause conflicts. Each account is linked to one primary URL. If you install scripts from two accounts, only one will work. Remove duplicate scripts and keep only the correct one.

Best Practices for Maintaining the Integration

Regularly check your SeaText dashboard. Ensure your website name is still displayed. If it disappears, the script may have been removed or blocked. Re-install the script if needed.

Keep your Square site updated. Square releases updates that may change how Code Injection works. After each update, verify the script is still present and working. Test on a staging site before updating your live site.

Monitor your browser console for errors. Set up a routine check every month. Look for any new errors related to SeaText. Early detection prevents long downtime.

Document your integration steps. Note the exact script you used and where you placed it. This helps if you need to re-install or troubleshoot later. Share this documentation with your team.

Use version control for your Square site if possible. Some Square plans allow code backups. If not, keep a copy of your script and settings in a secure location. This makes recovery faster.

Test after any changes to your Square site. Adding new apps, changing themes, or updating plugins can break the integration. Always test SeaText after such changes.

Limitations and When This Advice Doesn't Apply

This guide covers common integration issues. It does not cover:

• Problems with Square's own API or server outages. These are outside SeaText's control.
• Issues caused by custom code conflicts on your Square site. Custom JavaScript may interfere with SeaText's script.
• Advanced customization of SeaText AI beyond basic setup. This guide is for standard integration only.
• Problems with third-party plugins or themes that modify your site's code. These may require separate troubleshooting.

Some Square configurations are incompatible. For example, Square's free plan may not support third-party scripts. Also, Square's POS-only plans (without an online store) cannot use SeaText. The script requires a web page to run.

If you use a custom domain with Square, ensure the domain matches your SeaText account. Mismatched domains prevent activation. Also, dynamic development domains like localhost are restricted. Use a real domain for testing.

SeaText AI may not work with Square's older site builder (Square Online legacy). The newer Square Online editor is required. Check your Square site version. If you use the legacy builder, consider upgrading.

If your Square site uses a CDN or caching service, the script may not load correctly. Clear the cache after installing the script. Some CDNs block third-party scripts by default. Configure your CDN to allow seatext.com.

For complex issues, contact SeaText support. They can provide advanced debugging. This guide is a starting point, not a complete solution.

Frequently Asked Questions

Why doesn't my website name appear in SeaText after installation?

This usually means the script isn't installed correctly or the page hasn't been visited long enough. Re-check the code placement and visit your live site for at least 40 seconds. Wait up to 10 minutes for the dashboard to update.

Can I use SeaText AI on multiple Square stores?

Yes, but you need a separate SeaText account for each store. Each account is linked to one primary URL.

What if I see an error when trying to activate the AI?

First, check your Square plan supports third-party apps. Then verify the script is in the correct location. If the error persists, contact SeaText support.

Does SeaText AI work with Square's free plan?

Square's free plan may not support third-party app integrations. Check your Square account settings to confirm. If not, you may need to upgrade.

How long does it take for SeaText AI to start working?

After installing the script, visit your site for at least 40 seconds. Your website name should appear in the SeaText dashboard within 10 minutes. If not, contact support.

Can I edit the AI-generated content?

Yes. Log into your SeaText account, go to Variants Edit, select the URL and language, and make changes manually or with AI prompts.

What should I do if the script is installed but nothing happens?

Clear your browser cache and cookies. Then revisit your Square site and the SeaText dashboard. If it still doesn't work, re-copy the script and reinstall it.

How do I check if the script is loading?

Open your browser's developer tools (F12). Go to the Network tab. Reload your Square site. Look for a request to seatext.com. If you don't see it, the script is not installed.

Can other scripts block SeaText?

Yes. Analytics scripts, ad trackers, and custom JavaScript can cause conflicts. Place SeaText's script first in the header. Test with other scripts disabled to isolate the issue.

What if I use a custom Square theme?

Custom themes may modify the DOM. This can break SeaText's event listeners. Test on a staging site first. Contact the theme developer for compatibility.

Yes, you can move your Square integration from one SeaText account to another. The process involves disconnecting Square from your current SeaText account and then connecting it to the new one. After the switch, you will need to reconfigure some settings, such as which Square locations are linked and which AI agents are active on those pages.

Why You Might Want to Switch Accounts

There are a few common reasons to move a Square integration to a different SeaText account:

• Business separation: You have two distinct businesses (e.g., a retail store and a consulting service) and want to keep their data, billing, and AI settings completely separate.
• Account consolidation: You accidentally created two SeaText accounts and want to bring all integrations under one login.
• Team or ownership change: A new team member or agency takes over management of your website and needs the integration on their own SeaText account.
• Testing or staging: You used a development account to test Square and now want to move the live integration to your production account.

What Happens When You Switch

When you disconnect Square from your current SeaText account, the integration stops sending data to that account. Your Square account itself is not affected — payments, customers, and inventory remain unchanged in Square. After you reconnect Square to the new SeaText account, the integration will start fresh. You will need to:

• Re-authorize the connection via Square’s OAuth flow.
• Select which Square locations to link (if you have multiple).
• Activate the AI agents (e.g., Conversion Agent, Google Ads Agent) on the pages that use Square data.
• Reconfigure any custom settings, such as which product fields to sync or which triggers to use for AI actions.

Step-by-Step: How to Switch Square to a Different SeaText Account

Step 1: Disconnect Square from the Current SeaText Account

1. Log in to your current SeaText account.
2. Go to the Integrations section in the dashboard.
3. Find the Square integration and click Disconnect or Remove.
4. Confirm the disconnection. This will stop the data flow from Square to this account.

Step 2: Log In to the New SeaText Account

1. Log out of the current account.
2. Log in to the SeaText account where you want to move the integration. If you do not have one yet, create a new account.

Step 3: Connect Square to the New Account

1. In the new account, navigate to the Integrations section.
2. Select Square from the list of available integrations.
3. Click Connect or Authorize. You will be redirected to Square to log in and grant permission.
4. Follow the on-screen prompts to complete the OAuth authorization. Make sure you grant the necessary permissions for SeaText to access your Square data.

Step 4: Configure the Integration

1. After authorization, you will return to SeaText. Select which Square locations you want to link (if you have multiple).
2. Set up any location-specific settings, such as which products or orders to sync.
3. Activate the AI agents you need for those pages. For example, if you use the Google Ads Agent, you will need to configure it to rewrite landing pages based on Square product data.
4. Test the integration by visiting your website and checking that Square data (e.g., product prices, inventory status) appears correctly.

Step 5: Verify and Monitor

1. Wait at least 5 minutes after activation. Refresh your website and stay on the page for at least 40 seconds to ensure the AI activates and links to your account.
2. Check the SeaText dashboard to confirm your website name appears next to the SeaText logo at the top of the page. If it does not appear after 10 minutes, contact SeaText support.
3. Monitor the integration for a few days to ensure data syncs correctly and AI agents work as expected.

Key Facts About Switching Square Integrations

Limitations and When This Advice Does Not Apply

This process works for standard Square integrations with SeaText. However, there are some cases where the advice may differ:

• Multiple Square accounts: If you have more than one Square account (e.g., for different businesses), you will need to repeat the process for each one. Each Square account can only be linked to one SeaText account at a time.
• Custom development: If you have custom code that directly interacts with the Square API alongside SeaText, you may need to update that code to point to the new SeaText account.
• Enterprise or custom plans: If you are on a custom SeaText plan, check with your account manager before switching, as there may be specific setup requirements.
• Data history: Historical data from the previous integration (e.g., past AI agent performance reports) will remain in the old SeaText account. It will not transfer to the new account.

Frequently Asked Questions

Will I lose my Square data when I disconnect?

No. Disconnecting Square from SeaText only stops the data flow between the two services. Your Square account, transactions, customers, and inventory remain unchanged in Square.

Can I have Square connected to two SeaText accounts at the same time?

No. Each Square account can only be authorized with one SeaText account at a time. To switch, you must disconnect from the first account before connecting to the second.

How long does the switch take?

The disconnection and reconnection process takes about 5–10 minutes. After reconnecting, allow up to 5 minutes for the AI to activate on your website, and up to 10 minutes for your website name to appear in the SeaText dashboard.

Do I need to reinstall the SeaText script on my website?

No. The SeaText JavaScript code on your website remains the same. You only need to update the integration settings in the SeaText dashboard.

What if I forget to disconnect Square from the old account first?

If you try to connect Square to a new SeaText account while it is still connected to the old one, the authorization will fail. You must disconnect from the old account first.

Will my AI agents still work after the switch?

They will work, but you will need to reactivate and reconfigure them for the new account. The old account’s settings will not carry over.

Can I switch back to the original account later?

Yes. You can repeat the same process to move the integration back to the original account at any time.

Direct Answer: Step-by-Step Process to Connect SeaText AI to Square

To connect SeaText AI to your Square online store, follow this clear step-by-step process. The integration is secure and the AI stays inactive until you turn it on. This protects your site while you set up.

Why This Integration Matters for Your Square Store

SeaText AI helps Square store owners increase sales without extra work. It can improve conversion rates by testing headlines and CTAs automatically (source S2). It personalizes content for each visitor. It also automates A/B testing so you don't need to wait months for results (source S2). For stores with low traffic, this is a game changer. Traditional A/B testing needs thousands of visitors. SeaText AI uses reading behavior to find winning copy faster (source S2).

Integration Overview: Key Criteria at a Glance

Prerequisites: What You Need Before Starting

Before you begin the process, gather these items:

• SeaText AI Account: You must have an active account. Create one at the SeaText AI portal if you don't have one (source S1).
• Square Online Admin Access: You need permissions to edit your Square Online site settings.
• A Live Domain: Use a real, public domain. Localhost and dynamic development URLs are blocked for security (source S1).
• Separate Accounts for Multiple Domains: Each SeaText AI account works with only one primary URL. If you have a staging site and a live site, create two accounts (source S1).

Step-by-Step Integration Process

Follow these numbered steps exactly. The process is designed to be simple and secure.

Step 1: Install the SeaText App from Square App Marketplace

Go to the Square App Marketplace. Search for "SeaText AI." Click to install the app. This adds the integration to your Square account.

Step 2: Copy Your JavaScript Code from SeaText AI Dashboard

Log in to your SeaText AI dashboard. Navigate to the section labeled "Ask Seatext AI" or "Square integration" (source S1). You will see a JavaScript code block. It may be labeled as SEATEXTCODEINTEGRATION. Click the copy button to copy the code to your clipboard (source S1).

Step 3: Paste the Code into Square Online Settings

Sign in to your Square Dashboard. Go to Channels > Square Online. Click on Website and then Edit site. Find the site settings area where custom scripts are allowed. This is often in the header or footer injection section. Paste the copied JavaScript code into that field. Save your changes.

Step 4: Wait for Verification

Return to your SeaText AI dashboard. Wait at least five minutes (source S1). Look at the top of the SeaText page. You should see your website name displayed next to the SeaText logo. This confirms the connection is working. If you do not see it after 10 minutes, contact SeaText support (source S1).

Step 5: Activate the AI by Visiting Your Site

Visit or refresh your live website several times. Stay on the page for at least 40 seconds (source S1). This activity activates the AI and links it to your account. The AI remains inactive until you do this step.

Step 6: Configure and Activate AI Features

Once the connection is verified, go to the Main AI Hub in your SeaText dashboard. Click on "Configuration" to adjust AI parameters (source S1). You can activate specific AI features on your preferred pages. For example, you can turn on headline testing or translation.

How It Works: Technical Overview

SeaText AI uses a JavaScript snippet placed on your Square site. This snippet allows the AI to read visitor behavior in real time. It tracks how people read your pages. It measures eye-line dwell velocity, friction points, and scroll deceleration (source S2). The AI then generates and tests copy variants automatically. It can rewrite headlines, CTAs, and product descriptions to match visitor intent. This process happens at the edge with zero flicker (source S3). The AI stays inactive until you activate it, ensuring your content is safe.

Trade-Offs and Limitations

Understand these constraints before you start the process:

• Single Domain per Account: You cannot use one SeaText account for multiple websites. Each website needs its own account (source S1).
• No Localhost: Development URLs like localhost are blocked for security. Use a valid, real domain (source S1).
• Dynamic Domains May Fail: Dynamic development domains may not work properly. The system needs a stable URL to associate traffic with your account (source S1).
• Activation Requires Manual Visit: You must visit your site for 40+ seconds to activate the AI. This is a one-time step but easy to forget.

Practical Use Cases for Square Store Owners

Here are real scenarios where this integration helps:

• Increase Conversion Rates: SeaText AI tests headlines and CTAs automatically. It finds the version that gets more sales (source S2).
• Personalize Content: The AI adapts your landing page to match each visitor's source. For example, a visitor from Google Ads sees a headline that matches their search (source S4).
• Automate A/B Testing: Traditional A/B testing takes months for low-traffic stores. SeaText AI uses reading telemetry to get results faster (source S2).
• Translate Your Store: SeaText AI can translate your Square store into 125 languages. This opens new markets without manual work (source S3).
• Recover Ad Spend from Bots: The Bot Refund Agent detects invalid clicks and prepares refund claims for Google and Meta (source S5).

Frequently Asked Questions

How long does the integration process take?

The process takes about 10 minutes. Copy the code, paste it, wait 5 minutes for verification, then visit your site for 40 seconds.

Can I use one SeaText account for my main site and staging site?

No. Each SeaText AI account is linked to a single primary URL. Create separate accounts for each domain (source S1).

Why doesn't my website show up in the dashboard immediately?

The system needs time to verify the script. Wait at least five minutes. Also, visit your live site for 40+ seconds to activate the link (source S1).

Is the installation secure?

Yes. The AI remains inactive until you activate it. This protects your content. Localhost is blocked for security (source S1).

What if I use a dynamic development domain?

Dynamic domains may not work. The system relies on stable URLs. Use a valid, static domain for testing (source S1).

How do I edit the AI-generated content?

Log in to your SeaText AI account. Navigate to "Variants Edit" in the left panel. Select your URL and language. Here you can review, create, or manually edit translations and variants (source S1).

Can I use SeaText AI on multiple Square stores?

Yes, but each store needs its own SeaText AI account. Create one account per website (source S1).

Set Up Multiple Locations in the Square Sandbox

Before you can test multi-location behavior, you need more than one location in your sandbox account. Square automatically creates a main location when you sign up for a sandbox account. To add additional locations, use the Square Dashboard or the Locations API.

• Using the Dashboard: Log in to your Square Developer Dashboard, navigate to the sandbox account, and go to Locations. Click Create Location and fill in the details (name, address, time zone). You can create locations that represent different physical stores, online marketplaces, or warehouses.
• Using the Locations API: Call the CreateLocation endpoint with a valid access token from your sandbox application. The request body must include a location object with at least a name and country. The API returns the new location's ID, which you will use in subsequent tests.

After creating the locations, list them using the ListLocations endpoint to confirm they all appear and have unique IDs. This step verifies that your integration can retrieve the full list of locations.

Test Transactions Per Location

Each payment, order, or checkout request in Square requires a location_id. To test multi-location support, you must send requests using different location IDs and confirm the data is recorded under the correct location.

1. Create a test payment for Location A: Use the CreatePayment endpoint with the location ID of your first sandbox location. Use a test card number (e.g., 4111111111111111) and a nonce generated from the Square Sandbox. The response should include the location ID you sent.
2. Create a test payment for Location B: Repeat the same process but use the location ID of your second sandbox location. Use a different test card or the same one — the key is that the location ID changes.
3. Verify in the Sandbox Dashboard: Log in to your sandbox account and go to the Transactions or Payments section. Filter by location. You should see each payment under its respective location. If both payments appear under the same location, your integration is not passing the location ID correctly.

This test confirms that your integration can create transactions for any location and that Square correctly attributes them.

Test Data Retrieval Per Location

Multi-location integrations often need to fetch data for a specific location — for example, retrieving all orders for a particular store. Square's ListOrders, ListPayments, and SearchCatalogObjects endpoints all support filtering by location.

• List orders for Location A: Call ListOrders with the location ID of Location A. The response should include only orders created under that location.
• List orders for Location B: Repeat with Location B's ID. The response should be different (or empty if no orders exist).
• Search catalog items by location: If your integration uses location-specific pricing or inventory, call SearchCatalogObjects with a location filter. Verify that items with location-specific overrides appear correctly.

If your integration retrieves data without a location filter, it may return data from all locations. That is acceptable for some use cases, but you must ensure you can isolate data per location when needed.

Test Location-Specific Inventory

Square supports tracking inventory at the location level. To test this, create an inventory item and adjust its quantity for each location separately.

1. Create a catalog item using the UpsertCatalogObject endpoint. Set track_quantity to true.
2. Set inventory for Location A: Call BatchChangeInventory with the location ID of Location A and a positive quantity change (e.g., +10).
3. Set inventory for Location B: Call the same endpoint with Location B's ID and a different quantity (e.g., +5).
4. Retrieve inventory counts: Use RetrieveInventoryCount with the catalog object ID and each location ID. The counts should differ, confirming that inventory is tracked per location.

This test is critical for businesses that sell the same product in multiple stores and need accurate stock levels per location.

Test Location-Specific Settings and Configurations

Square allows you to configure different settings per location, such as business hours, payment processing options, and tax rates. Your integration should respect these differences.

• Retrieve location details: Call RetrieveLocation for each location ID. Verify that fields like business_hours, timezone, and capabilities are correct.
• Test location-specific taxes: If you have set up different tax rates for different locations, create an order for each location and confirm the tax calculation matches the expected rate.
• Test location-specific payment methods: Some locations may support different payment methods (e.g., cash vs. card). Use the ListPaymentMethods endpoint (if available) or check the location's capabilities.

If your integration ignores location-specific settings, it may apply incorrect taxes or offer unavailable payment methods, leading to errors in production.

Test Webhooks for Multiple Locations

Square sends webhooks for events like payment created, order updated, or inventory changed. Each webhook payload includes a location_id field. Your integration must use this field to route the event to the correct location's data pipeline.

1. Set up a webhook endpoint in your sandbox application. Use a tool like webhook.site or your own server.
2. Trigger events for different locations: Create a payment for Location A, then create a payment for Location B. Check the webhook payloads. Each should contain the correct location_id.
3. Verify your handler logic: Ensure your code reads the location_id and processes the event accordingly. A common mistake is to ignore the location ID and update a single data store, which would mix data from different locations.

This test ensures that your integration can handle real-time updates correctly when multiple locations are active.

Common Mistakes and How to Avoid Them

Even experienced developers make errors when testing multi-location integrations. Here are the most frequent pitfalls:

• Using the main location ID for everything: Some developers hardcode the main location ID during testing and forget to make it dynamic. Always use a variable for the location ID.
• Not testing with multiple locations in the sandbox: If you only test with one location, you won't catch issues where the location ID is missing or incorrect.
• Ignoring location ID in webhook handlers: Webhooks include a location ID, but if your handler ignores it, you may update the wrong location's data.
• Assuming all locations have the same settings: Tax rates, business hours, and payment methods can differ. Test with locations that have different configurations.

To avoid these mistakes, create a test plan that covers at least two locations with different settings and run all your test cases against both.

Key Facts About Square Multi-Location Testing

Fact	Details
Sandbox environment	Square provides a free sandbox for testing. You can create multiple locations within a single sandbox account.
Location ID required	Every API call that creates or retrieves data must include a valid location ID.
Test card numbers	Use Square's test card numbers (e.g., 4111111111111111) to simulate payments. They work in the sandbox only.
Webhook payloads	Each webhook includes a location_id field. Your handler must use it to route the event.
Inventory tracking	Inventory is tracked per location. You must specify the location ID when adjusting or retrieving stock.
Location-specific settings	Tax rates, business hours, and payment methods can vary by location. Test with different configurations.

Limitations of Sandbox Testing

The Square Sandbox is a powerful tool, but it has limitations you should know before moving to production.

• No real payments: You cannot process actual credit card transactions. Use test card numbers only.
• Limited data retention: Sandbox data may be periodically reset. Do not rely on it for long-term testing.
• No real-time processing: Some features, like instant transfers, are not available in the sandbox.
• Rate limits: The sandbox has lower rate limits than production. If you are load testing, use production credentials carefully.

Despite these limitations, the sandbox is sufficient for validating multi-location logic. Plan to run a final verification in production with a small test transaction before going live.

Frequently Asked Questions

How do I create multiple locations in the Square Sandbox?

Use the Square Developer Dashboard: navigate to your sandbox account, go to Locations, and click Create Location. Alternatively, use the CreateLocation API endpoint with a valid sandbox access token.

Can I use the same test card for multiple locations?

Yes. Test card numbers work for any location in the sandbox. The location ID in the request determines which location the payment is attributed to.

What happens if I forget to include a location ID?

Square returns an error. Most endpoints that require a location ID will return a 400 BAD_REQUEST with a message like "location_id is required".

Do webhooks include the location ID?

Yes. Every webhook payload from Square includes a location_id field. Your webhook handler must read this field to process the event for the correct location.

How do I test location-specific inventory?

Create a catalog item with inventory tracking enabled. Then use BatchChangeInventory with different location IDs to set stock levels. Retrieve counts with RetrieveInventoryCount to verify.

Can I test location-specific tax rates in the sandbox?

Yes. Set up different tax rates for different locations in the sandbox Dashboard. Then create orders for each location and verify the tax calculation.

What is the most common mistake when testing multi-location integrations?

Hardcoding the main location ID and not testing with multiple locations. Always use a variable for the location ID and test with at least two locations.

Further reading and comparison sources

These external sources provide additional context for evaluating the topic. Their inclusion is not an endorsement.

• How to Integrate Square With Jotform
• Test Square APIs in the Sandbox
• Locations API

What You Need Before Testing

Before you start testing, make sure you have these three things ready:

• A Square Developer account – Sign up at developer.squareup.com if you haven't already. This gives you access to the sandbox environment.
• Your ecommerce platform's test mode – Platforms like Shopify, WooCommerce, BigCommerce, and Wix each have a built-in test or sandbox mode. Enable it so no real charges are processed.
• Square test card numbers – Square provides specific card numbers that simulate successful payments, declined cards, and other scenarios. You can find these in the Square developer documentation.

Step 1: Enable Sandbox Mode in Square

Log in to your Square Developer Dashboard. Navigate to the sandbox settings and toggle sandbox mode on. This creates a separate environment that mimics the live Square system but uses fake data. No real transactions, customers, or inventory are affected.

Once sandbox mode is active, you will see a sandbox location in your dashboard. Use this location for all test transactions.

Step 2: Configure Your Ecommerce Platform for Testing

Each platform has a different way to enable test mode:

• Shopify – Go to Settings > Payments > Square. Enable test mode and enter your sandbox API credentials.
• WooCommerce – Install the Square plugin. In plugin settings, check the “Enable Sandbox Mode” box and enter your sandbox application ID and access token.
• BigCommerce – In the Square payment gateway settings, toggle “Test Mode” on and use sandbox API keys.
• Wix – In the Square integration settings, enable the sandbox option and paste your sandbox credentials.

If your platform is not listed, look for a “test mode” or “sandbox” toggle in the Square payment settings. The process is similar across most platforms.

Step 3: Place Test Orders Using Square Test Cards

Now you can simulate real purchases. Use the following test card numbers to trigger different outcomes:

• Successful payment – Use card number 4111 1111 1111 1111 with any future expiry date and any CVV.
• Declined payment – Use card number 4000 0000 0000 0002 to simulate a card decline.
• Insufficient funds – Use card number 4000 0000 0000 0003.
• Invalid card – Use card number 4000 0000 0000 0004.

Go to your ecommerce store's checkout page as a customer would. Enter one of these test card numbers along with any valid name, address, and future expiry date. Complete the order.

Repeat this process for each test card to verify how your store handles different payment outcomes.

Step 4: Verify Data Sync Between Square and Your Platform

After placing a test order, check that the information appears correctly in both systems:

• In your ecommerce platform – Look at the order details. The order should show as “paid” or “completed” for successful payments, and as “failed” or “declined” for declined ones.
• In the Square Dashboard – Go to the sandbox location and view the transactions. You should see the same test orders with matching amounts, card types, and statuses.

If the order appears in your platform but not in Square, or vice versa, there is a sync issue. Check your API credentials and webhook settings.

Step 5: Test Webhooks and Notifications

Square uses webhooks to send real-time updates about payments, refunds, and disputes to your platform. To test webhooks:

1. In your Square Developer Dashboard, go to Webhooks and add a test endpoint URL (you can use a service like webhook.site to capture the payload).
2. Place another test order. Square will send a webhook event to your endpoint.
3. Check that the webhook payload contains the correct order ID, payment status, and amount.

If your platform relies on webhooks to update order status, this step is critical. A missing or malformed webhook can cause orders to appear as unpaid even after a successful charge.

Step 6: Test Refunds and Partial Refunds

Refunds are a common part of ecommerce. Test the full refund flow:

1. In your ecommerce platform, initiate a refund for a test order that was paid with a successful test card.
2. Check that the refund appears in the Square Dashboard under the same transaction.
3. Verify that the order status in your platform updates to “refunded” or “partially refunded.”

Also test a partial refund to ensure your platform handles it correctly.

Key Facts About Testing Square Integration

Limitations of Testing in Sandbox

Sandbox testing is powerful, but it has limits:

• No real payment processing – You cannot test actual bank transfers, card-present transactions, or hardware integrations.
• No customer data – Sandbox does not create real customer profiles. You will not see email receipts or customer cards saved for future use.
• No chargebacks or disputes – You cannot simulate a customer disputing a charge. That flow can only be tested in production.
• Limited test card scenarios – Square provides only a handful of test cards. Complex scenarios like 3D Secure authentication may not be fully reproducible.

For these reasons, after passing sandbox tests, run a small set of live transactions with your own card to confirm everything works in production. Then immediately refund those transactions.

Frequently Asked Questions

Do I need a separate Square account for testing?

No. Your existing Square account can access the sandbox environment through the Developer Dashboard. You do not need a second account.

Can I test Square integration without a developer account?

No. The sandbox environment is only available through the Square Developer platform. You must create a developer account, which is free.

How long does it take to set up the sandbox?

About 10 to 15 minutes. Creating a developer account and enabling sandbox mode takes only a few clicks. Configuring your ecommerce platform with sandbox credentials takes a bit longer.

Will testing affect my live store data?

No. Sandbox data is completely isolated. Orders placed in sandbox mode do not appear in your live Square Dashboard or affect your inventory, customers, or reports.

What if my platform does not have a test mode?

Some custom-built or less common platforms may lack a built-in test mode. In that case, you can still test by using Square's API directly with sandbox credentials. You will need to manually verify data sync by checking API logs.

How do I know if my webhooks are working?

Use a webhook testing tool like webhook.site or requestbin.com. Configure Square to send webhooks to that URL, then place a test order. If you see the payload arrive, your webhooks are working.

What should I do if a test fails?

First, check your API credentials. Make sure you are using sandbox credentials, not live ones. Then check your platform's error logs. Square also provides detailed API error messages in the Developer Dashboard. Common issues include incorrect endpoint URLs, missing permissions, or mismatched location IDs.

Mistake 1: Using One Account for Multiple Websites

SeaText AI links each account to a single primary URL. If you try to use one account on two different Square websites, the AI will only work on the first site you set up. The second site will not be recognized, and you will see no AI activity or data for it.

To avoid this, create a separate SeaText AI account for each Square website you manage. Each account gets its own unique JavaScript code and configuration.

Managing multiple stores is a common requirement for entrepreneurs. However, the architecture of SeaText is designed for domain isolation. When you use the same script ID on multiple domains, the data will conflict or the script will fail to initialize on the secondary sites. By separating your accounts, you ensure that analytics and AI optimizations remain clean for each brand.

Mistake 2: Using Development or Localhost URLs

SeaText AI restricts development URLs like localhost for security reasons. If you try to install the script on a local development environment or a dynamic staging domain, the AI may not activate or may not reliably associate traffic with your account.

Always use a valid, real domain (e.g., yoursite.com or staging.yoursite.com) for each account. If you need a staging site, use a real subdomain or a separate production-like domain.

Security protocols are vital when handling AI-driven content. Localhost environments lack the public-facing headers required for SeaText servers to verify the connection. Always deploy to a live URL to ensure the AI handshake occurs correctly.

Mistake 3: Not Activating the AI After Installation

After adding the JavaScript code to your Square website, you must visit or refresh the site several times and stay on the page for at least 40 seconds. This step activates the AI and links it to your account. Skipping this means the AI remains inert.

Wait at least five minutes after activation until you see your website name next to the SeaText logo in your account dashboard. If it does not appear after 10 minutes, contact support.

The activation process is not instantaneous. The system needs to observe a real user session to confirm the script is executing as intended. If you leave the page immediately, the 40-second timer may reset, and the site will never show in your dashboard.

Mistake 4: Mixing Up Data Between Websites

When you manage multiple Square websites, it is easy to accidentally apply settings, translations, or A/B test variants from one site to another. Because each account is separate, you must log into the correct account before making changes.

Use clear naming conventions for your accounts (e.g., "MyStore - Main Site" and "MyStore - Blog") and always double-check the URL shown in the dashboard before editing variants or configurations.

Context switching is a high-risk activity. When multiple tabs are open with different accounts, users often copy a translation meant for a clothing store. Use different browser profiles for different accounts to prevent this error entirely.

Mistake 5: Ignoring Plan Limits

Each SeaText AI account may have its own plan limits for features like the number of AI agents, translations, or// tests. If you have multiple websites, you need a separate plan for each account. Check your plan details to ensure you are not exceeding limits, which could cause features to stop working.

Exceeding limits can lead to silent failures. For instance, if a site hits its translation cap, the AI might stop serving localized content to visitors. Monitor your usage metrics weekly to scale up before high-traffic events occur.

Mistake 6: Not Testing After Setup

After setting up SeaText AI on each Square website, test that the AI is working correctly. Visit each site, check that the AI agents are active, and verify that translations or copy variants appear as expected. A quick test can catch configuration errors early.

Use the SeaText dashboard to monitor activity for each account separately.

Verification is the final step of any technical deployment. Just because the code is pasted does not mean the AI is rendering. Use an incognito window to view your site as a customer would, ensuring that cached versions are not interfering with your tests.

The Mechanics of Multi-Domain Management

SeaText AI operates at the edge. This means it processes website content before it reaches the visitor's browser. When managing multiple sites, the edge server must know exactly which configuration profile to pull. If the account ID is shared or incorrect, the edge server cannot serve the correct AI agent or translation.

This is why the one-account-per-domain rule is strict. It protects the integrity of your A/B testing data and ensures that a traffic spike on one site does not impact the performance metrics of another store.

Decision Criteria for Account Structure

When deciding how to structure your accounts, consider the target audience for each site. If two sites share a brand and audience, you might consider subdirectories. However, if they are distinct entities with different goals, separate accounts are mandatory to prevent data bleeding.

Consider your budget as well. Each account requires its own subscription tier. If you are managing dozens of small sites, calculate the cost-per-site versus the benefit of isolation. For enterprise-level needs, contact sales for a custom multi-domain solution.

Practical Scenarios and Common Pitfalls

Scenario: You are launching a new seasonal store on a temporary domain. You use the same script from your main store. Result: The new store shows no data in your dashboard. Solution: Create a new account and generate a unique script for the seasonal domain.

Scenario: You are testing an A/B variant on your blog but accidentally apply it to your main store account. Result: Your main store shows unoptimized copy. Solution: Always verify the URL in the top corner of the dashboard before hitting 'Save'.

Key Facts

Limitations and When This Advice Does Not Apply

This advice applies to users who manage multiple Square websites and want to use SeaText AI on each. If you only have one Square website, you do not need multiple accounts. The advice does not apply if you are using a single domain with directories (e.g., site.com/store and site.com/blog) — SeaText AI can work on a single domain with sections, but each account is still tied to one URL.

If you use a platform other than Square, the same account-per-domain rule applies, but the integration steps may differ.

Frequently Asked Questions

Can I use the same SeaText AI account on two websites?

No. Each SeaText AI account is linked to a single primary URL. You must create a separate account for each website.

What happens if I install the same code on sites?

Only the first site where you activate the AI will work. The second site will not be recognized, and you will see no data for it.

How do I create a separate account for each website?

Sign up for a new SeaText AI account for each domain. You can use a different email or the same email with a plus sign (e.g., you+site2@example.com) if the platform allows it.

Can I use a staging subdomain like staging.mysite.com?

Yes, as long as it is a valid, real domain. Avoid localhost or development URLs.

How long does it take for the AI to activate?

After installing the code, visit the site several times and stay for at least 40 seconds. Your website name should appear in the dashboard within five to ten minutes.

What should I do if my website name does not appear after 10 minutes?

Contact SeaText support immediately. There may be an issue with the installation.

Do I need a separate plan for each account?

Yes, each account requires its own plan. Check your plan limits and contact sales if you need a custom multi-domain solution.