---
description: Use Groq's server-side tools for browser search and code execution without any setup.
title: Groq Built-In Tools - GroqDocs
image: https://console.groq.com/og_cloudv5.jpg
---

# Groq Built-In Tools

Built-in (or server-side) tools are the easiest way to add agentic capabilities to your application. Unlike [remote MCP](https://console.groq.com/docs/tool-use/remote-mcp) where you connect to external servers, or [local tool calling](https://console.groq.com/docs/tool-use/local-tool-calling) where you implement functions yourself, built-in tools require **zero orchestration**.

Just call the API, specify which tools you want to allow the model to use, and Groq's systems will handle the rest - tool execution, orchestration, and returning the final answer.

Built-in tools are not HIPAA Covered Cloud Services under Groq's Business Associate Addendum at this time. These tools are also not available currently for use with regional / sovereign endpoints.

## [How Built-In Tools Work](#how-builtin-tools-work)

With built-in tools, **execution happens entirely on Groq's servers**. The model autonomously calls built-in tools (web search, code execution) and handles the entire agentic loop internally. You get one response with everything completed.

Your App → Makes request to Groq API with tools parameter
   ↓
Groq API → Makes request to LLM with built-in tool definitions from 
           the tools parameter
         ← Model returns tool_calls with built-in tool names (or, if no 
           tool calls are needed, returns final response)
   ↓
Groq API → Parses tool call arguments server-side
         → Makes request to built-in tool with tool call arguments
         ← Built-in tool returns results
   ↓
Groq API → Makes another request to LLM with tool results
         ← Model returns more tool_calls (returns to step 3), or 
           returns final response
   ↓
Your App

## [Which Models Support Built-In Tools](#which-models-support-builtin-tools)

### [GPT-OSS Models](#gptoss-models)

OpenAI's open-weight models support a subset of built-in tools:

**Models:**

* `openai/gpt-oss-120b`
* `openai/gpt-oss-20b`

**Available Tools:**

| Tool                                   | Identifier        |
| -------------------------------------- | ----------------- |
| [Browser Search](https://console.groq.com/docs/browser-search) | browser\_search   |
| [Code Execution](https://console.groq.com/docs/code-execution) | code\_interpreter |

**Limitations:**

* Cannot use Visit Website or Wolfram Alpha

**How to use GPT-OSS models:**

Python

```
from groq import Groq

client = Groq()

# Automatically uses tools when needed
response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{
        "role": "user",
        "content": "What's the current population of Tokyo?"
    }]
)

# Or specify which tool to enable
response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{
        "role": "user",
        "content": "Search for recent AI developments"
    }],
    tools=[{"type": "browser_search"}]
)

print(response.choices[0].message.content)
```

```
import Groq from "groq-sdk";

const client = new Groq();

// Automatically uses tools when needed
const response = await client.chat.completions.create({
  model: "openai/gpt-oss-120b",
  messages: [{
    role: "user",
    content: "What's the current population of Tokyo?"
  }]
});

// Or specify which tool to enable
const responseWithTool = await client.chat.completions.create({
  model: "openai/gpt-oss-120b",
  messages: [{
    role: "user",
    content: "Search for recent AI developments"
  }],
  tools: [{ type: "browser_search" }]
});

console.log(response.choices[0].message.content);
```

GPT-OSS models are ideal when you need a large context window (131K tokens) with basic tool capabilities.

### [Configuring Tools](#configuring-tools)

Use the `tools` parameter with tool type objects. You can specify `browser_search` or `code_interpreter`.

Python

```
# Single tool
tools=[{"type": "browser_search"}]

# Or multiple tools
tools=[{"type": "browser_search"}, {"type": "code_interpreter"}]
```

```
// Single tool
const tools = [{ type: "browser_search" }];

// Or multiple tools
const tools = [{ type: "browser_search" }, { type: "code_interpreter" }];
```

### [Compatibility with Local Tool Calling and Remote MCP Tools](#compatibility-with-local-tool-calling-and-remote-mcp-tools)

GPT-OSS models can be used alongside local tool calling or remote MCP tools in the same request.

## [Next Steps](#next-steps)

[Remote Tools and MCPConnect to MCP servers for standardized tool integrations](https://console.groq.com/docs/tool-use/remote-mcp)[Local Tool CallingDefine and execute custom tools in your application code](https://console.groq.com/docs/tool-use/local-tool-calling)[Browser Search ToolDeep dive into the web search tool capabilities](https://console.groq.com/docs/browser-search)[Code Execution ToolLearn about running Python code securely](https://console.groq.com/docs/code-execution)