# NetSuite MCP

> Oracle NetSuite MCP Server connects your AI agent directly to your entire ERP system. Instead of clicking through dashboards, you talk to NetSuite and get answers for financial data, sales orders, inventory levels, and customer records instantly. Your agent can run complex SQL-like queries (`execute_suiteql`), generate new documents with `create_record`, or pull specific details using `get_record`. It's full ERP management via natural conversation.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** cloud-erp, financial-reporting, sales-orders, inventory-management, business-automation, procurement

## Description

**Oracle NetSuite MCP Server** connects your AI agent directly to your entire Enterprise Resource Planning system. Forget clicking through menus and dashboards; you just talk to NetSuite, and your agent pulls the answers for financial data, sales orders, inventory counts, or customer details instantly. You're running full ERP management purely through conversation.

Your AI client gets access to nine specific tools that let your agent act like a trained administrator inside NetSuite. It doesn't just read data—it makes changes and runs deep reports without you having to log into the UI yourself. This is about action, not just viewing.

**Running Custom Reports and Complex Queries**
You can run advanced, custom queries against any structured NetSuite dataset using SQL-like commands via `execute_suiteql`. You write standard SELECT, JOIN, and WHERE statements; the agent executes them directly on the database. This lets you build reports that would normally take an analyst hours to pull together.

**Listing and Auditing Records**
To get a broad view of your business assets, you use `list_records`, which pulls general lists for types like customers, vendors, or inventory items so you can audit the full range of data. You'll find `list_customers` gives you a complete roster of every customer account stored in NetSuite. If you need to check recent sales activity, `list_sales_orders` pulls a list of the most recently created or updated orders.

**Retrieving Specific Data Points**
When you know the exact ID of a record—say, an invoice number or a vendor ID—you use `get_record` to pull all available fields for that specific item. If you're building something and need to know what data is even possible on a certain record type before you try writing it, run through `get_record_metadata`. This tells you exactly which fields exist on any given NetSuite record structure.

**Creating and Modifying Records (Making Changes)**
Your agent can generate brand new business documents using `create_record`, provided you give it the specific record type and all the necessary field data. You'll create things like sales orders or journal entries this way. Similarly, you use `update_record` to change specific fields on an existing document—you have to specify exactly what needs changing so your agent doesn't mess anything up. For cleanup, `delete_record` permanently removes a record from NetSuite; remember that action is irreversible.

**Putting It Together in Practice**
When you use the server, your AI client sends an intent—for example, 'Show me all journal entries for Q3.' The MCP Server translates that into structured tool calls. If you need to run a report, it invokes `execute_suiteql`. To find specific sales data, it might call `list_sales_orders` and then use the results with `get_record`. You can manage the entire lifecycle of an item: listing vendors via `list_records`, getting a specific vendor's contact details using `get_record`, and finally creating a new payment record using `create_record`. The agent handles all the back-and-forth, returning actionable data or confirmation that the transaction went through.

## Tools

### create_record
Generates a brand new NetSuite record (like a sales order or journal entry) by requiring the specific record type and field data.

### delete_record
Permanently removes an existing NetSuite record. Note: This action is irreversible.

### execute_suiteql
Allows you to run advanced, custom SQL-like queries against any structured NetSuite data set (SELECT, JOIN, WHERE).

### get_record
Retrieves all available fields for a specific NetSuite record type when provided with the record's unique ID.

### get_record_metadata
Checks what fields are available on any given NetSuite record type before you attempt to create or modify it.

### list_customers
Retrieves a list of all customer accounts currently stored in NetSuite.

### list_records
Lists records by type, pulling broad lists like customers, vendors, or inventory items for general review.

### list_sales_orders
Pulls a list of the most recently created or updated sales orders.

### update_record
Changes specific fields on an existing NetSuite record, requiring you to specify exactly which data needs modification.

## Prompt Examples

**Prompt:** 
```
Show me the revenue breakdown by subsidiary for March 2026.
```

**Response:** 
```
Revenue by Subsidiary (March 2026): 1. US Operations — $2,340,000 (+12% MoM), 2. EU Operations — €1,150,000 (+8% MoM), 3. APAC — ¥89,500,000 (+15% MoM). Total consolidated revenue: $4,120,000. Want me to drill down into any subsidiary?
```

**Prompt:** 
```
Find all customers with overdue invoices above $10,000.
```

**Response:** 
```
Found 12 customers with overdue invoices > $10K: 1. GlobalTech Inc — $45,200 (32 days overdue), 2. Pinnacle Corp — $28,750 (18 days overdue), 3. Summit Holdings — $22,100 (45 days overdue)... Total overdue amount: $312,400. Want me to generate a collections follow-up list?
```

**Prompt:** 
```
Create a sales order for customer 'CUST-1045' with 100 units of item 'SKU-2024-A' at $45 each.
```

**Response:** 
```
Sales Order SO-2026-04567 created successfully! Customer: CUST-1045, Item: SKU-2024-A, Qty: 100, Unit Price: $45.00, Total: $4,500.00. Status: Pending Fulfillment. Would you like me to check stock availability or generate the pick ticket?
```

## Capabilities

### Run Custom Reports
Execute complex, custom queries against NetSuite's database using SQL-like commands via `execute_suiteql`.

### Create and Modify Records
Generate new business documents (sales orders, journal entries) or update existing records like customer contacts using `create_record` or `update_record`.

### Retrieve Specific Data Points
Fetch details on a single record—like an invoice or a specific item—using its ID via `get_record`.

### List and Audit Records
Get broad lists of records, such as all recent sales orders (`list_sales_orders`) or all vendors, to audit data ranges.

## Use Cases

### Month-End Close Reporting
A controller needs the total revenue breakdown by subsidiary. Instead of pulling 10 separate reports, they ask their agent: 'Show me the consolidated revenue for Q2.' The agent runs complex queries using `execute_suiteql` and returns a single, summarized financial report.

### Handling Late Payments
An accounts receivable specialist identifies several overdue clients. They tell their agent: 'Find all customers whose invoices are over $10k.' The agent uses `list_records` and filtering logic to compile a targeted list for the collections team.

### Fulfilling a Large Order
The sales team closes a huge deal. They instruct their agent: 'Create a sales order for CUST-XYZ with 50 units of SKU-A.' The agent uses `create_record`, ensuring the SO is properly logged, and then checks stock availability in real time.

### Auditing Vendor Accounts
The procurement team needs to reconcile a vendor's bill. They ask the agent to 'Get all purchase orders for Vendor B from last quarter.' The agent uses `list_sales_orders` and related tools, providing the necessary PO numbers for auditing.

## Benefits

- **Real-time Financial Visibility:** Instead of running reports in the UI, use `execute_suiteql` to query complex financial relationships and aggregate data instantly. You get results without navigating menus.
- **Automated Document Creation:** Never manually key in a sales order again. Use `create_record` to build fully structured SOs or POs just by telling your agent what needs doing.
- **Deep Inventory Checks:** Need to know stock levels across three warehouses? The agent can use `get_record` and related tools to query item records, giving you valuations and availability numbers right away.
- **Streamlined Customer Management:** Update customer credit limits or pull their full contact history using `update_record` and `list_customers`. It's faster than opening the profile page.
- **Error-Proof Development Flow:** When your agent needs to know what fields are available for an update, it uses `get_record_metadata`, preventing you from submitting forms with invalid data.

## How It Works

The bottom line is that your AI client treats NetSuite like a simple backend database accessible via chat commands.

1. Subscribe to the server and provide your NetSuite TBA credentials (Account ID, Consumer Key, Consumer Secret, Token ID, Token Secret).
2. Your AI agent sends a natural language request detailing the required action (e.g., 'Create an SO for customer X').
3. The MCP Server executes the appropriate tool function, performs the necessary NetSuite API calls, and returns structured data or confirmation of success.

## Frequently Asked Questions

**What credentials do I need for NetSuite authentication?**
You need 5 values for Token-Based Authentication (TBA): Account ID, Consumer Key, Consumer Secret, Token ID, and Token Secret. All are generated within your NetSuite account under Setup > Integration.

**Can I run custom SuiteQL queries?**
Yes. The `execute_suiteql` tool executes SQL-like queries against the SuiteQL endpoint. You can query any record type, join tables, and use aggregation functions — all through natural language that the agent translates to SuiteQL.

**Does it support NetSuite saved searches?**
Absolutely. Use the `run_saved_search` tool with the saved search ID to retrieve its results. This works with any existing saved search in your account — transactions, customers, items, or custom records.

**Can I create sales orders through the agent?**
Yes. The `create_record` tool with the `salesOrder` record type lets you create full sales orders with line items, pricing, shipping addresses, and payment terms — all through conversation.

**When I use the `list_records` tool, how do I filter results by date range or specific criteria?**
You can specify filtering parameters in the payload. The API accepts standard NetSuite filters like date ranges (start/end dates) and status codes. This lets you narrow down large result sets without needing to run complex full-text queries.

**When using the `update_record` tool, do I have to send all fields, or can I change just one?**
You only need to specify the exact fields you intend to modify. The system treats your payload as a partial update; it ignores any fields that aren't listed in your request body. This keeps data integrity high.

**If I use the `delete_record` tool, is there a way to verify or confirm what I'm about to delete?**
The API does not include a confirmation step before deletion. Always run `get_record` first using the record ID you plan to delete. This confirms its existence and allows you to audit its current data state prior to running the destructive action.

**When running massive queries with `execute_suiteql`, how do I handle performance or pagination?**
For huge result sets, the tool supports cursor-based pagination. You must pass the last record ID or offset from the previous results in your next call until you've retrieved all necessary data. This keeps processing fast and reliable.