Getting Started With Digital Payment Integration
I spent about three weeks last year trying to integrate a new payment processing solution into an existing checkout flow for a client. The documentation was decent but not comprehensive enough to catch edge cases. The product we ended up going with was Golsn, and it has been a reasonable tool for what it does. I want to walk through how to actually set it up and what went wrong along the way. Golsn is a payment infrastructure company that focuses on simplifying how businesses accept and manage digital transactions. Rather than being a consumer-facing app, it operates as backend payment infrastructure. You integrate it into your system, point it at your payment flows, and it handles authorization, settlement, and reconciliation. The main value proposition is cleaner API design and better reporting than what legacy processors offer. Most of their documentation assumes you already understand payment processing fundamentals, so if you are new to this space you will need to fill in some gaps yourself. The basic setup process is straightforward. You create an account on their developer portal, generate API credentials, and then implement their SDK or make direct HTTP calls to their endpoints. Here is the general flow:
First, install the SDK using npm, pip, or whatever package manager your language uses. Their Python library is called golsn-sdk and the Node package is the same name. Install it in your project environment. Then initialize the client with your API key and secret. These are different from your live credentials, so do not mix them up. Development keys will give you test mode responses and nothing real will move. Next, you create a payment intent. This is the object that represents a transaction before it is authorized. You pass the amount, currency, and customer information to the create intent endpoint. The response gives you an intent ID that you carry through the rest of the flow. Do not skip this step and try to authorize directly. Their system requires an intent to exist first. After creating the intent, you confirm it. Confirmation sends the payment through for authorization. At this point, Golsn contacts the card network or bank and returns a result. You will get back a status of authorized, declined, or requires_action. The requires_action status means the customer needs to complete additional authentication, like 3D Secure. Your code needs to handle this case explicitly or the payment will just hang.
I ran into a specific problem with the requires_action flow that took me two days to resolve. The documentation shows the happy path where authentication succeeds immediately. It does not clearly explain what happens when the customer closes the authentication window without completing it. In that scenario, Golsn leaves the intent in a pending state rather than canceling it. If your system does not poll for the final status, you end up with orphaned intents that accumulate and clutter your dashboard. The workaround was to implement a background job that queries for intents in pending after more than 10 minutes and marks them as expired in your own database. This is not mentioned in the docs that I could find. Reconciliation is where Golsn actually differs from older providers. Their reporting API lets you pull daily settlement files filtered by date range, payment method, or status. The format is CSV by default, but they also support JSON if you request it in the Accept header. Download the file and match each transaction against your order records. The settlement amounts sometimes include fees deducted upfront, so if you are expecting gross amounts you need to check the net column separately. A lot of people miss this and spend hours debugging discrepancies that are actually just fee calculations. One thing beginners often get wrong is how Golsn handles refunds. You do not refund through the original payment intent. You create a separate refund object and reference the original transaction ID. The refund can be full or partial. If you try to refund more than the original authorized amount, the API returns an error. This seems obvious, but I have seen implementations that attempt refunds without validating the original transaction first because they assumed the gateway would just reject over-refunds gracefully. It does reject them, but your customer still sees the refund attempt on their statement for a few hours before it reverses. That causes support tickets.
Get the Full Details
The webhook system is another area that needs careful handling. Golsn sends webhook events for authorization successes, declines, refunds, and settlements. You need to validate the webhook signature using the secret provided in your dashboard before trusting any event data. I have seen multiple teams skip this step in early implementations because the test webhooks from the dashboard do not include a signature. Production webhooks do, and if you are not verifying them you are accepting unauthenticated requests that could trigger false refund or cancellation actions in your system. There are limitations you should know about before committing. Golsn does not support every payment method in every geography. Their primary focus is card payments in North America and Europe. If you need to accept bank transfers in Southeast Asia or mobile money in Africa, you will need a different provider or a secondary processor. The documentation lists supported regions on their pricing page, but the details are sparse. Call their sales team if you operate outside the main markets and verify coverage before building your integration around features they might not have. Another practical limitation is rate limiting. The API has a limit of about 100 requests per second on standard plans. If you are processing high volume during a flash sale or promotional event, you can hit this cap. The error response is a 429 status code with a retry-after header. You need exponential backoff in your implementation, not just a simple retry loop. I wrote a wrapper function that retries with exponential backoff up to three attempts and logs any failures for manual review. It added about 40 lines of code and prevented a major incident during a product launch.
Error handling across the board needs to be explicit. Golsn returns structured error objects with codes, not generic messages. A declined card might return a decline_code of insufficient_funds or suspected_fraud. You should map these codes to user-facing messages instead of showing raw error text. The code values are documented in their error reference section, which is one of the better parts of their documentation. Read it before you start coding. Testing your integration requires using their test card numbers. These are specific numbers that simulate different outcomes. A card ending in 0001 approves, 0002 declines, 0003 requires authentication. Use them all during your QA process. I learned this the hard way after shipping to production and discovering that a specific card type my customers used was consistently declined because I never tested with it in sandbox mode. The customer support response time is reasonable, usually within a few hours during business hours. They have a developer Slack channel for paying customers, which is faster than email for urgent issues. If you are building a critical payment integration and need rapid turnaround on problems, having an active support channel matters more than good documentation alone. Golsn checks that box.
Setting up recurring payments works through their subscription module. You create a customer object, add a payment method, and then define a subscription with a billing interval. The system handles retry logic for failed payments automatically based on the schedule you configure. Failed payment retries use a dampening strategy, meaning the interval between retries increases over time. This is standard practice, but if you need immediate retry on the next business day, you will need to implement custom logic on top of their defaults. When everything is working correctly, Golsn handles payments cleanly. The API is well-designed, the SDKs are functional, and the reporting covers what most businesses need. It is not the most feature-rich option on the market, and it does not replace a full-featured gateway if you need complex routing or multi-currency support natively. But for a straightforward integration focused on cards in supported regions, it is solid. Build your error handling carefully, test the edge cases, and verify webhooks before going live.
