Match Buy Orders to a number of Vendor Payments in NetSuite

Matching a number of vendor payments to a single buy order is a typical activity in lots of AP processes, so it is best to know deal with this example in NetSuite. The excellent news is that Oracle has a bunch of choices that will help you streamline this course of – you should utilize the NetSuite UI, the API, or SuiteScript.

On this information, we’ll discover hyperlink a single buy order to a number of vendor payments, utilizing every of those strategies. We’ll additionally talk about the restrictions and advantages of utilizing the APIs.

It is vital to notice that the complexity of the NetSuite API will be overwhelming. It takes a whole lot of devoted time (and energy) to arrange an API integration and really automate your NetSuite workflows.

That is the place Nanonets is available in, offering a plug-and-play integration with NetSuite that eliminates the effort and confusion, making PO matching automation easy.

Nanonets automates vendor invoice entry into NetSuite, and units up seamless 2-way and 3-way PO matching in lower than quarter-hour!

However earlier than we get too far forward of ourselves, let’s first perceive match a number of vendor payments to a PO with ease.

Matching a PO to A number of Vendor Payments on the NetSuite UI

Utilizing the NetSuite UI to match a single buy order (PO) to a number of vendor payments is an easy activity, ideally suited for smaller operations or companies that do not want automation. This methodology means that you can create payments for various line objects on a PO or for partial portions of things.

Step-by-Step Directions:

1. Entry the Buy Order:
   • Navigate to Transactions > Purchases > Enter Buy Orders to find the PO you need to match.
2. Invoice the Buy Order:
   • Click on on Invoice on the highest header row of the Buy Order.
3. Edit the Invoice Line Particulars:
   • By default all of the strains of the PO can be added to the seller invoice. You possibly can take away the strains that aren’t required, in order that the PO is barely partially billed for the required line objects.
   • In case you could partially invoice any line (for eg, if you have not acquired all the amount for that merchandise) – you may edit the amount billed at this stage.
4. Repeat for Extra Vendor Payments:
   • If the PO requires a number of payments, repeat the method, deciding on the remaining objects or portions on the PO.

Word that the created vendor payments will NOT present up within the “Billing” subtab on the acquisition order. They are going to be seen in associated data solely. It is because NetSuite solely does a 1-time replace utilizing their ‘Remodel’ perform to transform a PO right into a vendor invoice.

Matching a PO to A number of Vendor Payments Utilizing the API

NetSuite supplies each SOAP and REST APIs (these are 2 totally different API applied sciences which can be generally utilized by builders). Whereas the SOAP API is older and extra mature, it may also be gradual in efficiency. The NetSuite REST API is extra fashionable (it was launched in 2019 by Oracle) however does not have the in depth help and customisation capabilities that the SOAP API has.

For this text, we’ll use the instance of the SOAP API to do the PO matching with Vendor Payments.

There are 2 approaches you may take to hyperlink a purchase order order to a vendor invoice:

1. Use the purchaseOrderList tag to reference a PO when creating the seller invoice – doing this may pull in ALL of the objects and bills current on that PO
2. Use an Initialize request and choose merchandise and expense strains from current POs – doing this has the benefit of having the ability to choose particular strains from the PO. You may as well use this to handle the use case of a number of POs in a single vendor invoice.

Step-by-Step Directions:

1. Retrieve the Buy Order File:

Retrieve the small print of the acquisition order utilizing the get operation. This supplies entry to the PO’s line objects, portions, and remaining portions.

Payload:

<get>
    <baseRef internalId="PO_ID" kind="purchaseOrder"/>
</get>

2. Create Vendor Invoice for First Invoice:

As we noticed above, in the event you use method 1 – use the add operation to create a vendor invoice for the primary set of line objects or portions from the PO.

Payload:

<add xmlns="urn:messages_2017_1.platform.webservices.netsuite.com">   
            <file xsi:kind="ns6:VendorBill" xmlns:ns6="urn:purchases_2017_1.transactions.webservices.netsuite.com">    
               <ns6:entity internalId="98" xsi:kind="ns7:RecordRef" xmlns:ns7="urn:core_2017_1.platform.webservices.netsuite.com"/>    
               <ns6:purchaseOrderList xsi:kind="ns8:RecordRefList" xmlns:ns8="urn:core_2017_1.platform.webservices.netsuite.com">     
                  <ns8:recordRef internalId="2659" kind="purchaseOrder" xsi:kind="ns8:RecordRef"/>     
                  <ns8:recordRef internalId="2661" kind="purchaseOrder" xsi:kind="ns8:RecordRef"/>    
               </ns6:purchaseOrderList>   
            </file>  
  </add>

For those who’re utilizing method 2, the payload can be:

<initialize xmlns="urn:messages_2017_1.platform.webservices.netsuite.com">   
            <initializeRecord>    
               <ns7:kind xmlns:ns7="urn:core_2017_1.platform.webservices.netsuite.com">vendorBill</ns7:kind>    
               <ns8:referenceList xmlns:ns8="urn:core_2017_1.platform.webservices.netsuite.com">     
                  <ns8:initializeRef internalId="2659" kind="purchaseOrder"/>     
                  <ns8:initializeRef internalId="2661" kind="purchaseOrder"/>    
               </ns8:referenceList>   
            </initializeRecord>  
</initialize>

3. Repeat for Extra Vendor Payments:

1. Repeat the method so as to add extra payments, adjusting the road objects and portions for every vendor invoice.

SOAP API vs REST API: Key Variations

We’ll go into a little bit extra element since that is one thing that always comes up in NetSuite growth – what’s the distinction, actually, between these two sorts of APIs given by Oracle?

SOAP API:

• Authentication: SOAP makes use of Token-Primarily based Authentication (TBA), which is OAuth1-based. Although older, it’s well-supported in enterprise settings and comparatively straightforward to configure.
• Metadata Dealing with: SOAP handles commonplace entities and fields nicely however struggles with customized fields with out extra workarounds.
• Saved Searches and File Cupboard: SOAP supplies built-in help for saved searches and file cupboard operations, making it the popular alternative for advanced knowledge retrieval duties.
• Efficiency: SOAP is gradual (however secure) and ideally suited for big, advanced integrations, although the syntax is extra verbose and difficult in comparison with REST.

REST API:

• Authentication Flexibility: REST helps OAuth2 along with TBA. Nonetheless, OAuth2 in NetSuite has some caveats, reminiscent of frequent token expirations for the Authorization Code Grant methodology.
• Metadata Dealing with: REST permits for extra dynamic entry to metadata, making it helpful for environments the place entity constructions change incessantly. REST additionally helps OpenAPI schemas, together with for customized fields.
• SuiteQL Assist: REST consists of help for SuiteQL, which may considerably simplify advanced queries by permitting SQL-like queries through the API.
• Limitations: REST remains to be comparatively new in NetSuite, and lots of data are nonetheless in beta. Essential features like saved searches and file cupboard entry require workarounds, reminiscent of customized Restlets.

Matching a PO to Vendor Payments Utilizing SuiteScript

For firms that require a extremely custom-made answer, SuiteScript supplies a strong JavaScript-based scripting platform to match buy orders with a number of vendor payments. SuiteScript permits full management over workflows and is extra helpful in circumstances the place customization is vital.

Step-by-Step Directions:

1. Load the Buy Order:

var poRecord = file.load({
    kind: file.Kind.PURCHASE_ORDER,
    id: 'PO_ID'
});

Use SuiteScript’s file.load methodology to entry the acquisition order.

2. Create the Vendor Invoice:

outline(['N/record', 'N/search'], perform(file, search) {
  
  perform createVendorBillFromPO(poId) {
    strive {
      // Load the Buy Order file
      var purchaseOrder = file.load({
        kind: file.Kind.PURCHASE_ORDER,
        id: poId
      });

      // Create a brand new Vendor Invoice
      var vendorBill = file.create({
        kind: file.Kind.VENDOR_BILL,
        isDynamic: true
      });

      // Set the Vendor and different fundamental particulars from the PO
      vendorBill.setValue({
        fieldId: 'entity',
        worth: purchaseOrder.getValue('entity')  // Vendor from PO
      });

      // Copy over every other header-level fields from the PO if needed
      // (e.g. phrases, subsidiary, and so forth.)
      vendorBill.setValue({
        fieldId: 'phrases',
        worth: purchaseOrder.getValue('phrases')
      });

      // Add PO line objects to the Vendor Invoice
      var lineCount = purchaseOrder.getLineCount({ sublistId: 'merchandise' });
      for (var i = 0; i < lineCount; i++) {
        var orderdoc = purchaseOrder.getSublistValue({
          sublistId: 'merchandise',
          fieldId: 'orderdoc',
          line: i
        });
        var orderline = purchaseOrder.getSublistValue({
          sublistId: 'merchandise',
          fieldId: 'orderline',
          line: i
        });

        // Choose the present line within the Vendor Invoice
        vendorBill.selectNewLine({ sublistId: 'merchandise' });

        // Set the required fields (orderdoc and orderline are vital for matching)
        vendorBill.setCurrentSublistValue({
          sublistId: 'merchandise',
          fieldId: 'orderdoc',
          worth: orderdoc  // PO Inside ID
        });
        vendorBill.setCurrentSublistValue({
          sublistId: 'merchandise',
          fieldId: 'orderline',
          worth: orderline  // PO line quantity
        });

        // Set the merchandise, amount, and charge (copying from PO)
        vendorBill.setCurrentSublistValue({
          sublistId: 'merchandise',
          fieldId: 'merchandise',
          worth: purchaseOrder.getSublistValue({
            sublistId: 'merchandise',
            fieldId: 'merchandise',
            line: i
          })
        });

        vendorBill.setCurrentSublistValue({
          sublistId: 'merchandise',
          fieldId: 'amount',
          worth: purchaseOrder.getSublistValue({
            sublistId: 'merchandise',
            fieldId: 'amount',
            line: i
          })
        });

        vendorBill.setCurrentSublistValue({
          sublistId: 'merchandise',
          fieldId: 'charge',
          worth: purchaseOrder.getSublistValue({
            sublistId: 'merchandise',
            fieldId: 'charge',
            line: i
          })
        });

        // Commit the road to the Vendor Invoice
        vendorBill.commitLine({ sublistId: 'merchandise' });
      }

      // Save the Vendor Invoice
      var vendorBillId = vendorBill.save();
      log.debug('Vendor Invoice created', 'Vendor Invoice ID: ' + vendorBillId);

      return vendorBillId;

    } catch (e) {
      log.error('Error creating Vendor Invoice', e);
      throw e;
    }
  }

  return {
    createVendorBillFromPO: createVendorBillFromPO
  };

});

Create a vendor invoice file utilizing file.create. The above code copies over all of the strains from the PO to the seller invoice – if wanted, you may choose the suitable line objects from the PO and map them to the seller invoice. This lets you match every PO line merchandise to the seller invoice line merchandise.

3. Repeat for A number of Payments:

Use this logic to create extra vendor payments by deciding on remaining PO strains in subsequent script executions.

Benefits of SuiteScript:

• Full Customization: SuiteScript presents whole management over the method, making it good for distinctive billing workflows.
• Extensibility: You possibly can simply construct on the script to deal with different customized wants like validation, logging, or error dealing with.

Frequent Errors and Troubleshooting

1. The PO is totally billed and acquired, however nonetheless reveals Pending Invoice
   1. That is possible as a result of the seller invoice has been created as a standalone invoice (i.e., a invoice not linked to a PO). You possibly can confirm this by checking the Associated Data sub-tab on the invoice for the PO hyperlink (or verify the journal entry – a standalone invoice can be tagged to Stock, whereas a PO-linked invoice can be tagged to Accruals).
2. I need to hyperlink a vendor invoice the place acquired amount is greater than the unique PO
   1. On this case, it is normally finest to finish the receiving and billing, conserving that data as correct as attainable, after which operating PVBV (Submit Vendor Invoice Variances) on the PO strains to search out and modify the errors to Accrued Purchases and your GL.
3. I need to match a number of POs to a single invoice
   1. In some circumstances you may need to match multiple PO to a single vendor invoice (if, for instance, you acquired a mixed bill for a lot of POs on the identical vendor). This may be addressed utilizing the SOAP API as described above, utilizing the Initialize methodology.

Utilizing end-to-end Workflow Automation for PO Matching

For those who’re utilizing NetSuite to run your funds and CRM operations, it is fairly possible you are already operating a manufacturing deployment of NetSuite, and all of your workflows are arrange and getting used day by day.

In such a situation, it is perhaps simpler to work with an integration associate who can migrate your processes and automate a manufacturing atmosphere, with out you having to get into the messy particulars of API integrations and SuiteQL queries.

That is what full-scale NetSuite automation on Nanonets appears like:

Enthusiastic about studying extra? A brief 15-minute intro name with an automation professional is one of the best ways to get began.

Conclusion

Matching a purchase order order to a number of vendor payments in NetSuite will be dealt with in a number of methods, relying on your corporation setup. You possibly can go for one thing that’s extra guide and offers you extra management, or you may totally automate it utilizing the API (with considerably greater effort and a few coding concerned).

By combining the perfect of each worlds utilizing a no-code answer like Nanonets, you may confidently handle vendor merchandise codes, streamline knowledge entry, and cut back guide errors, saving useful time to your procurement and finance groups.

References: