How to Create Sales Orders on NetSuite using the API

On the subject of working your AR course of on NetSuite, one of the vital frequent duties you may do is creating gross sales orders.

Manually creating gross sales orders will be tedious – the NetSuite UI isn’t very easy, and there are additional complexities which can be current solely within the API and never on the NetSuite UI software.

Nonetheless, the complexity of the NetSuite API will be tough to cope with. It takes a whole lot of devoted time (and energy) to set up an API integration and really automate your NetSuite workflows.

On this information we’ll undergo a step-by-step course of on methods to use the NetSuite API to create gross sales orders, in addition to automation options that may make the job simpler.

Nanonets automates gross sales order entry into NetSuite, and units up seamless 2-way matching with funds in lower than quarter-hour!

Understanding Gross sales Orders in NetSuite

A Gross sales Order is a transaction between a enterprise and a buyer the place the shopper commits to buying services or products. Gross sales orders are important for monitoring stock, income, and buyer funds. NetSuite’s API lets you create, handle, and fulfill these orders programmatically.

There are 4 foremost sorts of gross sales orders in NetSuite:

1. Normal Gross sales Order: The default sort for normal gross sales transactions the place fee is due upon supply.
2. Normal Gross sales Order – Money: Used for gross sales transactions the place fee is made on the time of the sale.
3. Normal Gross sales Order – Bill: Permits the sale to be invoiced at a later time, typically after the services or products has been delivered.
4. Normal Gross sales Order – Progress Billing: Used for giant tasks that require billing in phases or milestones, as work progresses.

The usual gross sales order is probably the most versatile of all of those, and it provides you with probably the most variety of choices to enter as fields. While you create a regular gross sales order, you mainly want to decide on these 5-6 fields:

• The client
• The transaction date (defaulted to the present date)
• The gross sales order standing (Pending Approval or Pending Achievement)
• The gadgets/companies that you’re promoting
• The fee phrases
• The fee methodology

Nonetheless, in lots of instances, it is perhaps helpful to make use of one of many different 3 sorts of gross sales orders – particularly whenever you already know upfront what sort of sale it will be (for eg. a money sale). The profit to doing that’s that lots of the fields will likely be pre-populated for you, saving effort and time.

Organising the NetSuite API

Earlier than you can begin creating gross sales orders utilizing the NetSuite API, you may must arrange your account entry and guarantee correct authentication.

We’ve revealed a separate, detailed guide on setting up the NetSuite API – you possibly can at all times get began there after which come again right here.

In case you already know methods to run API calls and simply want quick-start directions for NetSuite authentication, right here’s how you are able to do it:

Acquire Account Credentials:

1. Log in to your NetSuite account.
2. Navigate to Setup > Firm > Allow Options.
3. Below the SuiteCloud tab, be certain that REST Net Companies and Token-Based mostly Authentication are enabled.

Create an Integration Document:

1. Go to Setup > Integration > Handle Integrations > New.
2. Fill out the required fields, and notice down the Client Key and Client Secret supplied.

Set Up Token-Based mostly Authentication (TBA):

1. Navigate to Setup > Customers/Roles > Entry Tokens > New.
2. Choose the combination document you created, and generate the Token ID and Token Secret.

Together with your Account ID, Client Key, Client Secret, Token ID, and Token Secret, you are now able to make authenticated API calls to NetSuite.

Making a Gross sales Order in NetSuite

The NetSuite API lets you create Gross sales Orders programmatically, making certain seamless integration between methods. Under is a step-by-step information to making a Gross sales Order utilizing NetSuite’s REST API in python.

Authentication

Earlier than making any API calls to NetSuite, you want to authenticate utilizing OAuth 1.0. The next Python code makes use of the requests_oauthlib library to authenticate the request utilizing your consumer_key, consumer_secret, token_key, and token_secret.

Here is the way you authenticate utilizing OAuth 1.0:

import requests
from requests_oauthlib import OAuth1

# Authentication particulars
auth = OAuth1('consumer_key', 'consumer_secret', 'token_key', 'token_secret')

When you’re authenticated, you are able to construct your payloads.

Create Gross sales Order Payload

That is the primary payload that sends the gross sales order knowledge to NetSuite. On this, we’re in a position to outline what sort of gross sales order we’re creating. We take 2 examples beneath from the 4 sorts of gross sales orders that we noticed earlier.

1. Normal Merchandise-Based mostly Gross sales Order

In case your gross sales order entails tangible merchandise, right here’s methods to construction the payload for the standard gross sales order:

item_payload = {
    "entity": {"id": "1234"},  # Buyer ID
    "trandate": "2024-09-01",  # Transaction Date
    "duedate": "2024-09-15",  # Due Date
    "foreign money": {"id": "1"},  # Forex ID (USD)
    "phrases": {"id": "1"},  # Fee phrases
    "merchandise": [
        {
            "item": {"id": "5678"},  # Item ID
            "quantity": 10,  # Quantity
            "rate": 20.00  # Unit price
        }
    ],
    "memo": "Gross sales order for workplace provides"
}

2. Progress Billing Gross sales Order

For big tasks which can be billed incrementally, right here’s the construction for a progress billing gross sales order:

progress_billing_payload = {
    "entity": {"id": "5678"},  # Buyer ID
    "trandate": "2024-09-01",  # Transaction Date
    "duedate": "2024-09-15",  # Due Date
    "foreign money": {"id": "1"},  # Forex ID (USD)
    "merchandise": [
        {
            "item": {"id": "service_item_id"},  # Service Item ID
            "quantity": 1,  # Quantity
            "rate": 200.00,  # Rate
            "percentcomplete": 50  # Percentage complete for progress billing
        }
    ],
    "memo": "Consulting companies for September"
}

Ship POST Request

As soon as the payload is created, the following step is to ship a POST request to the NetSuite API utilizing the authenticated session. Under is the perform to deal with the request:

def create_sales_order(auth, payload):
    url = "https://<account_id>.suitetalk.api.netsuite.com/companies/relaxation/document/v1/salesOrder"
    
    headers = {"Content material-Kind": "software/json"}
    
    # Ship POST request to create the gross sales order
    response = requests.submit(url, json=payload, headers=headers, auth=auth)

    return response

# Ship the gross sales order creation request
response = create_sales_order(auth, payload)

URL: That is the NetSuite REST API endpoint for creating gross sales orders. Exchange <account_id> together with your precise NetSuite account ID.

Response Dealing with

As soon as the POST request is made, the API returns a response. It is best to verify the standing of the response and deal with it accordingly. If the gross sales order is created efficiently, the response will embrace particulars such because the gross sales order ID and standing.

# Response Dealing with
if response.status_code == 200:
    print("Gross sales Order created efficiently:", response.json())
else:
    print("Error creating Gross sales Order:", response.status_code, response.textual content)

Instance of profitable Gross sales Order creation

As soon as the gross sales order is created efficiently it can present up within the NetSuite UI as beneath:

Obtain Full Code:

The core code for posting a gross sales order utilizing NetSuite stays constant. Nonetheless, the payload varies relying on the kind of gross sales order being added. Let’s discover methods to ship a POST request so as to add numerous sorts of gross sales orders utilizing the NetSuite API.

How one can Retrieve Inner IDs in NetSuite

To populate the mandatory fields within the payloads (corresponding to itemID, currencyID, termsID, and accountID), you may want to make use of NetSuite’s Inner IDs. These IDs correspond to particular entities, gadgets, or phrases inside your NetSuite account.

You will discover these inner IDs by way of the next steps:

• NetSuite UI: Navigate to the related document (e.g., Vendor, Merchandise, or Account) within the NetSuite dashboard and allow “Inner IDs” below Dwelling -> Set Preferences -> Common -> Defaults -> Present Inner IDs.

• Saved Searches: Navigate to Stories -> Saved Searches -> All Saved Searches within the NetSuite dashboard. Create a brand new search and choose the related document sort (e.g., Gadgets, Clients). Within the Outcomes tab, add the Inner ID discipline as a column. Operating the search will show the interior IDs of the chosen data in your outcomes.
• SuiteScript: You may write and deploy a SuiteScript that retrieves inner IDs from data. After deploying the script, you possibly can run it to entry inner IDs to be used in your API calls. Under an instance of a easy SuiteScript to retrieve inner IDs of shoppers:

/**
 * @NApiVersion 2.x
 * @NScriptType Suitelet
 */
outline(['N/search'], perform(search) {
    perform onRequest(context) {
        var customerSearch = search.create({
            sort: search.Kind.CUSTOMER,
            columns: ['internalid', 'entityid']  // inner ID and Buyer title
        });

        var searchResult = customerSearch.run();
        var prospects = [];

        searchResult.every(perform(consequence) {
            prospects.push({
                internalId: consequence.getValue({ title: 'internalid' }),
                customerName: consequence.getValue({ title: 'entityid' })
            });
            return true;  // proceed iteration
        });

        // Ship again response as JSON
        context.response.write(JSON.stringify(prospects));
    }

    return {
        onRequest: onRequest
    };
});

With these inner IDs, you possibly can guarantee your API calls goal the right data, enhancing accuracy and effectivity in your gross sales order creation course of.

Dealing with Gross sales Order Fulfilment and Fee Situations in NetSuite

When creating gross sales orders in NetSuite, the kind of fee phrases that you just’re making use of can fluctuate, and can typically rely upon one other variable – when the gross sales order is getting fulfilled.

There are a couple of frequent duties that you’ll normally should do:

1. Apply a buyer fee to a Gross sales Order
2. Dealing with reductions and credit
3. Rework a Gross sales Order into an Merchandise Fulfilment

Making use of Buyer Funds to Gross sales Orders

As soon as a gross sales order is created, buyer funds will be utilized utilizing this payload:

payment_data = {
    "buyer": {"id": "customer_id"},
    "salesOrder": {"id": "sales_order_id"},
    "fee": {
        "quantity": 500,
        "methodology": {"id": "payment_method_id"}  # Fee Methodology ID (e.g., bank card)
    }
}

payment_url="https://your_netsuite_instance/relaxation/customerpayment/v1/"
response = requests.submit(payment_url, json=payment_data, auth=auth)
print(response.json())

Making use of Reductions or Credit to Gross sales Orders

To use reductions or credit to a gross sales order, replace the payload like this:

sales_order_data["discountitem"] = {"id": "discount_id"}  # Low cost ID
response = requests.submit(url, json=sales_order_data, auth=auth)
print(response.json())

Rework a Gross sales Order into an Merchandise Fulfilment

As soon as a gross sales order is able to be fulfilled, you possibly can rework the gross sales order into an merchandise success utilizing the NetSuite API. This course of ensures that the gadgets within the gross sales order are marked as shipped or delivered.

This may be finished as a NetSuite rework – i.e., you modify the gross sales order to an merchandise fulfilment.

Right here’s an instance API name for instantly remodeling a gross sales order into merchandise success:

POST /document/v1/salesOrder/<Sales_Order_id>/!rework/itemFulfillment

{
        "inventoryLocation": {
                "id" : <location id>
        }
...
} 

          

Observe that the inventoryLocation discipline is obligatory when remodeling a Gross sales Order to an Merchandise Achievement (you want to specify from the place within the stock you’re transport the gadgets that you just simply bought).

Frequent Pitfalls and Troubleshooting

Creating gross sales orders through the NetSuite API is a strong technique to automate your AR course of, however it comes with its challenges. Listed below are some frequent pitfalls and methods to keep away from them:

Create Gross sales Orders on Netsuite utilizing Nanonets

Nanonets simplifies the method by dealing with the complexities of API authentication, scope administration, and error dealing with, making it an preferrred end-to-end NetSuite automation workflow supplier.

By leveraging the AI-powered Nanonets platform, you possibly can automate all the vendor invoice creation course of in NetSuite with minimal human intervention. This ensures quicker processing occasions, improved accuracy, and seamless integration together with your present workflows.

Nanonets intelligently extracts key knowledge out of your inner CRM in addition to paperwork, maps it instantly into NetSuite, and generates correct gross sales orders.

Right here’s a demo video exhibiting how one can arrange automated NetSuite workflows utilizing Nanonets in below 2 minutes.

Benefits of Utilizing Nanonets:

• Native NetSuite Connection: Handles all of the intricate particulars like API authentication and lacking fields.
• Out-of-the-Field Workflows: Simplifies duties like gross sales order creation and fee software.
• Correct Knowledge Extraction: Leverages Gen AI fashions to extract knowledge from invoices and different paperwork.
• Person and Knowledge Administration: Gives options like doc storage and administration and group collaboration.
• Approval Workflows: Permits for knowledge verification inside your group earlier than posting to NetSuite.

By automating the gross sales order creation course of with Nanonets, you possibly can guarantee effectivity, accuracy, and scalability in your accounts receivable workflow, leaving the tedious duties to AI.

For extra data, take a look at the Nanonets documentation.

Nanonets automates gross sales order and fee entry into NetSuite, plus units up seamless 2-way, 3-way, and 4-way matching in minutes!

Conclusion

Creating gross sales orders in NetSuite utilizing the API streamlines your accounts receivable course of, from dealing with a number of gadgets and recurring funds to making use of reductions.

However why cease at simply guide API calls? Nanonets takes automation a step additional. By harnessing AI, Nanonets automates the extraction and enter of important gross sales order knowledge instantly into NetSuite, saving you time and eliminating the chance of human error.