Every capability, on every surface.

With the server connected, say something like:

Use the ToolForte tool text_diff (Text Diff) with original: one
two
three, modified: one
two point five
three.

The assistant then makes this tool call:

{
  "name": "text_diff",
  "arguments": {
    "original": "one\ntwo\nthree",
    "modified": "one\ntwo point five\nthree"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-diff \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"original":"one\ntwo\nthree","modified":"one\ntwo point five\nthree"}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-diff", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "original": "one\ntwo\nthree",
    "modified": "one\ntwo point five\nthree"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-diff",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"original":"one\ntwo\nthree","modified":"one\ntwo point five\nthree"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool markdown_to_html (Markdown to HTML) with markdown: # Hello

This is **bold** text..

The assistant then makes this tool call:

{
  "name": "markdown_to_html",
  "arguments": {
    "markdown": "# Hello\n\nThis is **bold** text."
  }
}

curl -X POST https://toolforte.com/api/v1/tools/markdown-to-html \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"markdown":"# Hello\n\nThis is **bold** text."}'

const response = await fetch("https://toolforte.com/api/v1/tools/markdown-to-html", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "markdown": "# Hello\n\nThis is **bold** text."
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/markdown-to-html",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"markdown":"# Hello\n\nThis is **bold** text."},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool count_words (Word) with text: The quick brown fox jumps over the lazy dog..

The assistant then makes this tool call:

{
  "name": "count_words",
  "arguments": {
    "text": "The quick brown fox jumps over the lazy dog."
  }
}

curl -X POST https://toolforte.com/api/v1/tools/word-counter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"The quick brown fox jumps over the lazy dog."}'

const response = await fetch("https://toolforte.com/api/v1/tools/word-counter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "The quick brown fox jumps over the lazy dog."
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/word-counter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"The quick brown fox jumps over the lazy dog."},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_slug (Slug) with text: Hello World! This is a Test., separator: -, lowercase: true, max_length: 0.

The assistant then makes this tool call:

{
  "name": "generate_slug",
  "arguments": {
    "text": "Hello World! This is a Test.",
    "separator": "-",
    "lowercase": true,
    "max_length": 0
  }
}

curl -X POST https://toolforte.com/api/v1/tools/slug-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello World! This is a Test.","separator":"-","lowercase":true,"max_length":0}'

const response = await fetch("https://toolforte.com/api/v1/tools/slug-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Hello World! This is a Test.",
    "separator": "-",
    "lowercase": true,
    "max_length": 0
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/slug-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Hello World! This is a Test.","separator":"-","lowercase":true,"max_length":0},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_case (Text Case) with text: hello world from ToolForte, mode: snake.

The assistant then makes this tool call:

{
  "name": "convert_case",
  "arguments": {
    "text": "hello world from ToolForte",
    "mode": "snake"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-case-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello world from ToolForte","mode":"snake"}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-case-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "hello world from ToolForte",
    "mode": "snake"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-case-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"hello world from ToolForte","mode":"snake"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool sort_lines (Sort Lines) with text: banana
apple
Cherry
item10
item2, mode: natural, caseInsensitive: true, removeDuplicates: false, reverse: false, seed: 1.

The assistant then makes this tool call:

{
  "name": "sort_lines",
  "arguments": {
    "text": "banana\napple\nCherry\nitem10\nitem2",
    "mode": "natural",
    "caseInsensitive": true,
    "removeDuplicates": false,
    "reverse": false,
    "seed": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sort-lines \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"banana\napple\nCherry\nitem10\nitem2","mode":"natural","caseInsensitive":true,"removeDuplicates":false,"reverse":false,"seed":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/sort-lines", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "banana\napple\nCherry\nitem10\nitem2",
    "mode": "natural",
    "caseInsensitive": true,
    "removeDuplicates": false,
    "reverse": false,
    "seed": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sort-lines",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"banana\napple\nCherry\nitem10\nitem2","mode":"natural","caseInsensitive":true,"removeDuplicates":false,"reverse":false,"seed":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dedupe_lines (Remove Duplicate Lines) with text: apple
banana
apple
 banana
cherry, caseInsensitive: false, trim: true, keepFirst: true.

The assistant then makes this tool call:

{
  "name": "dedupe_lines",
  "arguments": {
    "text": "apple\nbanana\napple\n banana\ncherry",
    "caseInsensitive": false,
    "trim": true,
    "keepFirst": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/remove-duplicate-lines \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"apple\nbanana\napple\n banana\ncherry","caseInsensitive":false,"trim":true,"keepFirst":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/remove-duplicate-lines", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "apple\nbanana\napple\n banana\ncherry",
    "caseInsensitive": false,
    "trim": true,
    "keepFirst": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/remove-duplicate-lines",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"apple\nbanana\napple\n banana\ncherry","caseInsensitive":false,"trim":true,"keepFirst":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool reverse_text (Reverse Text) with text: one two three, mode: words.

The assistant then makes this tool call:

{
  "name": "reverse_text",
  "arguments": {
    "text": "one two three",
    "mode": "words"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/reverse-text \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"one two three","mode":"words"}'

const response = await fetch("https://toolforte.com/api/v1/tools/reverse-text", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "one two three",
    "mode": "words"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/reverse-text",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"one two three","mode":"words"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool find_and_replace (Find and Replace) with text: The cat sat on the mat with another cat., find: cat, replace: dog, caseSensitive: false, wholeWord: true, useRegex: false.

The assistant then makes this tool call:

{
  "name": "find_and_replace",
  "arguments": {
    "text": "The cat sat on the mat with another cat.",
    "find": "cat",
    "replace": "dog",
    "caseSensitive": false,
    "wholeWord": true,
    "useRegex": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/find-and-replace \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"The cat sat on the mat with another cat.","find":"cat","replace":"dog","caseSensitive":false,"wholeWord":true,"useRegex":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/find-and-replace", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "The cat sat on the mat with another cat.",
    "find": "cat",
    "replace": "dog",
    "caseSensitive": false,
    "wholeWord": true,
    "useRegex": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/find-and-replace",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"The cat sat on the mat with another cat.","find":"cat","replace":"dog","caseSensitive":false,"wholeWord":true,"useRegex":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool word_frequency (Word Frequency) with text: the cat and the dog and the bird, ignoreCase: true, minLength: 1, excludeStopWords: false, limit: 3.

The assistant then makes this tool call:

{
  "name": "word_frequency",
  "arguments": {
    "text": "the cat and the dog and the bird",
    "ignoreCase": true,
    "minLength": 1,
    "excludeStopWords": false,
    "limit": 3
  }
}

curl -X POST https://toolforte.com/api/v1/tools/word-frequency-counter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"the cat and the dog and the bird","ignoreCase":true,"minLength":1,"excludeStopWords":false,"limit":3}'

const response = await fetch("https://toolforte.com/api/v1/tools/word-frequency-counter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "the cat and the dog and the bird",
    "ignoreCase": true,
    "minLength": 1,
    "excludeStopWords": false,
    "limit": 3
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/word-frequency-counter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"the cat and the dog and the bird","ignoreCase":true,"minLength":1,"excludeStopWords":false,"limit":3},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool reading_time (Reading Time) with text: Knowing how long your content takes to read helps you pla..., readingWpm: 238, speakingWpm: 150.

The assistant then makes this tool call:

{
  "name": "reading_time",
  "arguments": {
    "text": "Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.",
    "readingWpm": 238,
    "speakingWpm": 150
  }
}

curl -X POST https://toolforte.com/api/v1/tools/reading-time-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.","readingWpm":238,"speakingWpm":150}'

const response = await fetch("https://toolforte.com/api/v1/tools/reading-time-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.",
    "readingWpm": 238,
    "speakingWpm": 150
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/reading-time-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Knowing how long your content takes to read helps you plan articles, documentation and talks. This short paragraph is here as a sample.","readingWpm":238,"speakingWpm":150},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool rot13 (ROT13) with text: Hello, World!, shift: 13, decode: false.

The assistant then makes this tool call:

{
  "name": "rot13",
  "arguments": {
    "text": "Hello, World!",
    "shift": 13,
    "decode": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/rot13 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello, World!","shift":13,"decode":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/rot13", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "Hello, World!",
    "shift": 13,
    "decode": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/rot13",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"Hello, World!","shift":13,"decode":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool morse_code (Morse Code Translator) with text: SOS help, mode: encode.

The assistant then makes this tool call:

{
  "name": "morse_code",
  "arguments": {
    "text": "SOS help",
    "mode": "encode"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/morse-code-translator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"SOS help","mode":"encode"}'

const response = await fetch("https://toolforte.com/api/v1/tools/morse-code-translator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "SOS help",
    "mode": "encode"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/morse-code-translator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"SOS help","mode":"encode"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool numbers_to_words (Numbers to Words) with number: 1234.56, mode: plain, currency: dollars, british: false.

The assistant then makes this tool call:

{
  "name": "numbers_to_words",
  "arguments": {
    "number": "1234.56",
    "mode": "plain",
    "currency": "dollars",
    "british": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/numbers-to-words \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"number":"1234.56","mode":"plain","currency":"dollars","british":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/numbers-to-words", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "number": "1234.56",
    "mode": "plain",
    "currency": "dollars",
    "british": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/numbers-to-words",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"number":"1234.56","mode":"plain","currency":"dollars","british":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool roman_numerals (Roman Numeral) with value: 1994, mode: auto.

The assistant then makes this tool call:

{
  "name": "roman_numerals",
  "arguments": {
    "value": "1994",
    "mode": "auto"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/roman-numeral-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":"1994","mode":"auto"}'

const response = await fetch("https://toolforte.com/api/v1/tools/roman-numeral-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": "1994",
    "mode": "auto"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/roman-numeral-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":"1994","mode":"auto"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool clean_text (Text Cleaner) with text: <p>Hello   world</p>


  “quoted”  text  , extraSpaces: true, trimLines: true, emptyLines: true, lineBreaks: false, htmlTags: true, punctuation: false, numbers: false, emojis: false, plainQuotes: true, controlChars: false.

The assistant then makes this tool call:

{
  "name": "clean_text",
  "arguments": {
    "text": "<p>Hello   world</p>\n\n\n  “quoted”  text  ",
    "extraSpaces": true,
    "trimLines": true,
    "emptyLines": true,
    "lineBreaks": false,
    "htmlTags": true,
    "punctuation": false,
    "numbers": false,
    "emojis": false,
    "plainQuotes": true,
    "controlChars": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/text-cleaner \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<p>Hello   world</p>\n\n\n  “quoted”  text  ","extraSpaces":true,"trimLines":true,"emptyLines":true,"lineBreaks":false,"htmlTags":true,"punctuation":false,"numbers":false,"emojis":false,"plainQuotes":true,"controlChars":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/text-cleaner", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "<p>Hello   world</p>\n\n\n  “quoted”  text  ",
    "extraSpaces": true,
    "trimLines": true,
    "emptyLines": true,
    "lineBreaks": false,
    "htmlTags": true,
    "punctuation": false,
    "numbers": false,
    "emojis": false,
    "plainQuotes": true,
    "controlChars": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/text-cleaner",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"<p>Hello   world</p>\n\n\n  “quoted”  text  ","extraSpaces":true,"trimLines":true,"emptyLines":true,"lineBreaks":false,"htmlTags":true,"punctuation":false,"numbers":false,"emojis":false,"plainQuotes":true,"controlChars":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_subtitles (Subtitle) with text: 1
00:00:01,000 --> 00:00:03,500
Hello there., format: vtt, shiftSeconds: -2.5, scalePercent: 104.271, repair: true, appendText: 1
00:00:00,500 --> 00:00:02,000
Part two begins., appendOffsetSeconds: 5400.

The assistant then makes this tool call:

{
  "name": "convert_subtitles",
  "arguments": {
    "text": "1\n00:00:01,000 --> 00:00:03,500\nHello there.",
    "format": "vtt",
    "shiftSeconds": -2.5,
    "scalePercent": 104.271,
    "repair": true,
    "appendText": "1\n00:00:00,500 --> 00:00:02,000\nPart two begins.",
    "appendOffsetSeconds": 5400
  }
}

curl -X POST https://toolforte.com/api/v1/tools/subtitle-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"1\n00:00:01,000 --> 00:00:03,500\nHello there.","format":"vtt","shiftSeconds":-2.5,"scalePercent":104.271,"repair":true,"appendText":"1\n00:00:00,500 --> 00:00:02,000\nPart two begins.","appendOffsetSeconds":5400}'

const response = await fetch("https://toolforte.com/api/v1/tools/subtitle-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "1\n00:00:01,000 --> 00:00:03,500\nHello there.",
    "format": "vtt",
    "shiftSeconds": -2.5,
    "scalePercent": 104.271,
    "repair": true,
    "appendText": "1\n00:00:00,500 --> 00:00:02,000\nPart two begins.",
    "appendOffsetSeconds": 5400
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/subtitle-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"1\n00:00:01,000 --> 00:00:03,500\nHello there.","format":"vtt","shiftSeconds":-2.5,"scalePercent":104.271,"repair":true,"appendText":"1\n00:00:00,500 --> 00:00:02,000\nPart two begins.","appendOffsetSeconds":5400},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool format_json (JSON) with json: {"name":"ToolForte","version":1}, action: format, indent: 2.

The assistant then makes this tool call:

{
  "name": "format_json",
  "arguments": {
    "json": "{\"name\":\"ToolForte\",\"version\":1}",
    "action": "format",
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-formatter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"name\":\"ToolForte\",\"version\":1}","action":"format","indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-formatter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"name\":\"ToolForte\",\"version\":1}",
    "action": "format",
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-formatter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"name\":\"ToolForte\",\"version\":1}","action":"format","indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool csv_to_json (CSV to JSON) with csv: name,age
Alice,30
Bob,25, first_row_headers: true.

The assistant then makes this tool call:

{
  "name": "csv_to_json",
  "arguments": {
    "csv": "name,age\nAlice,30\nBob,25",
    "first_row_headers": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-to-json \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"csv":"name,age\nAlice,30\nBob,25","first_row_headers":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-to-json", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "csv": "name,age\nAlice,30\nBob,25",
    "first_row_headers": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-to-json",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"csv":"name,age\nAlice,30\nBob,25","first_row_headers":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_csv (JSON to CSV) with json: [{"name":"Alice","address":{"city":"Utrecht"}},{"name":"B..., delimiter: ,, includeHeader: true, flatten: true.

The assistant then makes this tool call:

{
  "name": "json_to_csv",
  "arguments": {
    "json": "[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]",
    "delimiter": ",",
    "includeHeader": true,
    "flatten": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-csv \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]","delimiter":",","includeHeader":true,"flatten":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-csv", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]",
    "delimiter": ",",
    "includeHeader": true,
    "flatten": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-csv",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"[{\"name\":\"Alice\",\"address\":{\"city\":\"Utrecht\"}},{\"name\":\"Bob\",\"address\":{\"city\":\"Leiden\"}}]","delimiter":",","includeHeader":true,"flatten":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_yaml (JSON to YAML) with json: {"name":"ToolForte","tags":["fast","free"],"owner":null}, indent: 2, sortKeys: false, nullStyle: null.

The assistant then makes this tool call:

{
  "name": "json_to_yaml",
  "arguments": {
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}",
    "indent": 2,
    "sortKeys": false,
    "nullStyle": "null"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-yaml \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}","indent":2,"sortKeys":false,"nullStyle":"null"}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-yaml", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}",
    "indent": 2,
    "sortKeys": false,
    "nullStyle": "null"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-yaml",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"],\"owner\":null}","indent":2,"sortKeys":false,"nullStyle":"null"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool yaml_to_json (YAML to JSON) with yaml: name: ToolForte
tags:
  - fast
  - free
port: 8080, indent: 2.

The assistant then makes this tool call:

{
  "name": "yaml_to_json",
  "arguments": {
    "yaml": "name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080",
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/yaml-to-json \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"yaml":"name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080","indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/yaml-to-json", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "yaml": "name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080",
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/yaml-to-json",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"yaml":"name: ToolForte\ntags:\n  - fast\n  - free\nport: 8080","indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool xml_to_json (XML to JSON) with xml: <order id="42"><item sku="A1">Bolts</item><item sku="B2">..., attributePrefix: @, dropNamespaces: true, indent: 2.

The assistant then makes this tool call:

{
  "name": "xml_to_json",
  "arguments": {
    "xml": "<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>",
    "attributePrefix": "@",
    "dropNamespaces": true,
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/xml-to-json \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"xml":"<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>","attributePrefix":"@","dropNamespaces":true,"indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/xml-to-json", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "xml": "<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>",
    "attributePrefix": "@",
    "dropNamespaces": true,
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/xml-to-json",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"xml":"<order id=\"42\"><item sku=\"A1\">Bolts</item><item sku=\"B2\">Nuts</item></order>","attributePrefix":"@","dropNamespaces":true,"indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_xml (JSON to XML) with json: {"name":"ToolForte","tags":["fast","free"]}, rootName: product, declaration: true.

The assistant then makes this tool call:

{
  "name": "json_to_xml",
  "arguments": {
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}",
    "rootName": "product",
    "declaration": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-xml \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}","rootName":"product","declaration":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-xml", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}",
    "rootName": "product",
    "declaration": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-xml",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"name\":\"ToolForte\",\"tags\":[\"fast\",\"free\"]}","rootName":"product","declaration":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool format_xml (XML) with xml: <a><b x="1">text</b><c/></a>, mode: pretty, indent: 2.

The assistant then makes this tool call:

{
  "name": "format_xml",
  "arguments": {
    "xml": "<a><b x=\"1\">text</b><c/></a>",
    "mode": "pretty",
    "indent": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/xml-formatter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"xml":"<a><b x=\"1\">text</b><c/></a>","mode":"pretty","indent":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/xml-formatter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "xml": "<a><b x=\"1\">text</b><c/></a>",
    "mode": "pretty",
    "indent": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/xml-formatter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"xml":"<a><b x=\"1\">text</b><c/></a>","mode":"pretty","indent":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool csv_to_markdown (CSV to Markdown) with csv: name,age
Alice,30
Bob,25, delimiter: auto, firstRowHeader: true, padded: true, alignment: left.

The assistant then makes this tool call:

{
  "name": "csv_to_markdown",
  "arguments": {
    "csv": "name,age\nAlice,30\nBob,25",
    "delimiter": "auto",
    "firstRowHeader": true,
    "padded": true,
    "alignment": "left"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-to-markdown \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"csv":"name,age\nAlice,30\nBob,25","delimiter":"auto","firstRowHeader":true,"padded":true,"alignment":"left"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-to-markdown", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "csv": "name,age\nAlice,30\nBob,25",
    "delimiter": "auto",
    "firstRowHeader": true,
    "padded": true,
    "alignment": "left"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-to-markdown",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"csv":"name,age\nAlice,30\nBob,25","delimiter":"auto","firstRowHeader":true,"padded":true,"alignment":"left"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool build_utm_url (UTM) with url: https://example.com/pricing?ref=1, source: newsletter, medium: email, campaign: spring_sale, term: running_shoes, content: header_banner.

The assistant then makes this tool call:

{
  "name": "build_utm_url",
  "arguments": {
    "url": "https://example.com/pricing?ref=1",
    "source": "newsletter",
    "medium": "email",
    "campaign": "spring_sale",
    "term": "running_shoes",
    "content": "header_banner"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/utm-builder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com/pricing?ref=1","source":"newsletter","medium":"email","campaign":"spring_sale","term":"running_shoes","content":"header_banner"}'

const response = await fetch("https://toolforte.com/api/v1/tools/utm-builder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "url": "https://example.com/pricing?ref=1",
    "source": "newsletter",
    "medium": "email",
    "campaign": "spring_sale",
    "term": "running_shoes",
    "content": "header_banner"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/utm-builder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"url":"https://example.com/pricing?ref=1","source":"newsletter","medium":"email","campaign":"spring_sale","term":"running_shoes","content":"header_banner"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool merge_csv (CSV Merge) with files: [{"name":"jan.csv","text":"id,amount\n1,10\n"},{"name":"feb.csv","text":"amount,id\n20,2\n"}], mode: byHeader, sourceColumn: true, delimiter: ;.

The assistant then makes this tool call:

{
  "name": "merge_csv",
  "arguments": {
    "files": [
      {
        "name": "jan.csv",
        "text": "id,amount\n1,10\n"
      },
      {
        "name": "feb.csv",
        "text": "amount,id\n20,2\n"
      }
    ],
    "mode": "byHeader",
    "sourceColumn": true,
    "delimiter": ";"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-merge \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"files":[{"name":"jan.csv","text":"id,amount\n1,10\n"},{"name":"feb.csv","text":"amount,id\n20,2\n"}],"mode":"byHeader","sourceColumn":true,"delimiter":";"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-merge", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "files": [
      {
        "name": "jan.csv",
        "text": "id,amount\n1,10\n"
      },
      {
        "name": "feb.csv",
        "text": "amount,id\n20,2\n"
      }
    ],
    "mode": "byHeader",
    "sourceColumn": true,
    "delimiter": ";"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-merge",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"files":[{"name":"jan.csv","text":"id,amount\n1,10\n"},{"name":"feb.csv","text":"amount,id\n20,2\n"}],"mode":"byHeader","sourceColumn":true,"delimiter":";"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool split_csv (CSV Split) with text: id,country
1,NL
2,BE
3,NL
, by: column, size: 1000, column: country, name: orders.

The assistant then makes this tool call:

{
  "name": "split_csv",
  "arguments": {
    "text": "id,country\n1,NL\n2,BE\n3,NL\n",
    "by": "column",
    "size": 1000,
    "column": "country",
    "name": "orders"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/csv-split \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"id,country\n1,NL\n2,BE\n3,NL\n","by":"column","size":1000,"column":"country","name":"orders"}'

const response = await fetch("https://toolforte.com/api/v1/tools/csv-split", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "id,country\n1,NL\n2,BE\n3,NL\n",
    "by": "column",
    "size": 1000,
    "column": "country",
    "name": "orders"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/csv-split",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"id,country\n1,NL\n2,BE\n3,NL\n","by":"column","size":1000,"column":"country","name":"orders"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool url_encode (URL Encoder/Decoder) with input: hello world & more, action: encode.

The assistant then makes this tool call:

{
  "name": "url_encode",
  "arguments": {
    "input": "hello world & more",
    "action": "encode"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/url-encoder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"hello world & more","action":"encode"}'

const response = await fetch("https://toolforte.com/api/v1/tools/url-encoder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": "hello world & more",
    "action": "encode"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/url-encoder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"input":"hello world & more","action":"encode"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool base64 (Base64 Encode/Decode) with input: ToolForte, action: encode.

The assistant then makes this tool call:

{
  "name": "base64",
  "arguments": {
    "input": "ToolForte",
    "action": "encode"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/base64 \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input":"ToolForte","action":"encode"}'

const response = await fetch("https://toolforte.com/api/v1/tools/base64", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "input": "ToolForte",
    "action": "encode"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/base64",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"input":"ToolForte","action":"encode"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool test_regex (Regex Tester) with pattern: \b\w+@\w+\.\w+\b, test_string: write to ada@example.com today, flags: g.

The assistant then makes this tool call:

{
  "name": "test_regex",
  "arguments": {
    "pattern": "\\b\\w+@\\w+\\.\\w+\\b",
    "test_string": "write to ada@example.com today",
    "flags": "g"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/regex-tester \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"pattern":"\\b\\w+@\\w+\\.\\w+\\b","test_string":"write to ada@example.com today","flags":"g"}'

const response = await fetch("https://toolforte.com/api/v1/tools/regex-tester", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "pattern": "\\b\\w+@\\w+\\.\\w+\\b",
    "test_string": "write to ada@example.com today",
    "flags": "g"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/regex-tester",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"pattern":"\\b\\w+@\\w+\\.\\w+\\b","test_string":"write to ada@example.com today","flags":"g"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool parse_cron (Cron Parser) with expression: 0 9 * * 1.

The assistant then makes this tool call:

{
  "name": "parse_cron",
  "arguments": {
    "expression": "0 9 * * 1"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/cron-parser \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"expression":"0 9 * * 1"}'

const response = await fetch("https://toolforte.com/api/v1/tools/cron-parser", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "expression": "0 9 * * 1"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/cron-parser",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"expression":"0 9 * * 1"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_uuids (UUID) with count: 3, format: uuid, display_format: default.

The assistant then makes this tool call:

{
  "name": "generate_uuids",
  "arguments": {
    "count": 3,
    "format": "uuid",
    "display_format": "default"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/uuid-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"count":3,"format":"uuid","display_format":"default"}'

const response = await fetch("https://toolforte.com/api/v1/tools/uuid-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "count": 3,
    "format": "uuid",
    "display_format": "default"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/uuid-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"count":3,"format":"uuid","display_format":"default"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool format_sql (SQL) with sql: select id, name from users where active = 1 and role = 'a....

The assistant then makes this tool call:

{
  "name": "format_sql",
  "arguments": {
    "sql": "select id, name from users where active = 1 and role = 'admin' order by name"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/sql-formatter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"sql":"select id, name from users where active = 1 and role = 'admin' order by name"}'

const response = await fetch("https://toolforte.com/api/v1/tools/sql-formatter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "sql": "select id, name from users where active = 1 and role = 'admin' order by name"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/sql-formatter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"sql":"select id, name from users where active = 1 and role = 'admin' order by name"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool html_entities (HTML Entity) with text: <a href="x">Tom & Jerry</a>, mode: encode, encodeNonAscii: false.

The assistant then makes this tool call:

{
  "name": "html_entities",
  "arguments": {
    "text": "<a href=\"x\">Tom & Jerry</a>",
    "mode": "encode",
    "encodeNonAscii": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/html-entity-encoder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"<a href=\"x\">Tom & Jerry</a>","mode":"encode","encodeNonAscii":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/html-entity-encoder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "<a href=\"x\">Tom & Jerry</a>",
    "mode": "encode",
    "encodeNonAscii": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/html-entity-encoder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"<a href=\"x\">Tom & Jerry</a>","mode":"encode","encodeNonAscii":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool json_to_typescript (JSON to TypeScript) with json: {"id":1,"name":"Ada","address":{"city":"Utrecht"},"tags":..., rootName: User, exportInterfaces: true, optionalProps: false, readonlyProps: false.

The assistant then makes this tool call:

{
  "name": "json_to_typescript",
  "arguments": {
    "json": "{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}",
    "rootName": "User",
    "exportInterfaces": true,
    "optionalProps": false,
    "readonlyProps": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/json-to-typescript \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"json":"{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}","rootName":"User","exportInterfaces":true,"optionalProps":false,"readonlyProps":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/json-to-typescript", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "json": "{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}",
    "rootName": "User",
    "exportInterfaces": true,
    "optionalProps": false,
    "readonlyProps": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/json-to-typescript",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"json":"{\"id\":1,\"name\":\"Ada\",\"address\":{\"city\":\"Utrecht\"},\"tags\":[\"a\",\"b\"]}","rootName":"User","exportInterfaces":true,"optionalProps":false,"readonlyProps":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool hash_text (Hash) with text: hello world, algorithm: SHA-256.

The assistant then makes this tool call:

{
  "name": "hash_text",
  "arguments": {
    "text": "hello world",
    "algorithm": "SHA-256"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/hash-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text":"hello world","algorithm":"SHA-256"}'

const response = await fetch("https://toolforte.com/api/v1/tools/hash-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "text": "hello world",
    "algorithm": "SHA-256"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/hash-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"text":"hello world","algorithm":"SHA-256"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool decode_jwt (JWT) with token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3..., now: 2026-09-07T12:00:00Z.

The assistant then makes this tool call:

{
  "name": "decode_jwt",
  "arguments": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
    "now": "2026-09-07T12:00:00Z"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/jwt-decoder \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c","now":"2026-09-07T12:00:00Z"}'

const response = await fetch("https://toolforte.com/api/v1/tools/jwt-decoder", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
    "now": "2026-09-07T12:00:00Z"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/jwt-decoder",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c","now":"2026-09-07T12:00:00Z"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_number_base (Number Base) with value: 255, fromBase: 10, toBase: 2.

The assistant then makes this tool call:

{
  "name": "convert_number_base",
  "arguments": {
    "value": "255",
    "fromBase": 10,
    "toBase": 2
  }
}

curl -X POST https://toolforte.com/api/v1/tools/number-base-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":"255","fromBase":10,"toBase":2}'

const response = await fetch("https://toolforte.com/api/v1/tools/number-base-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": "255",
    "fromBase": 10,
    "toBase": 2
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/number-base-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":"255","fromBase":10,"toBase":2},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool chmod (Chmod) with permissions: 755.

The assistant then makes this tool call:

{
  "name": "chmod",
  "arguments": {
    "permissions": "755"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/chmod-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"permissions":"755"}'

const response = await fetch("https://toolforte.com/api/v1/tools/chmod-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "permissions": "755"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/chmod-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"permissions":"755"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool http_status (HTTP Status Codes) with query: 404.

The assistant then makes this tool call:

{
  "name": "http_status",
  "arguments": {
    "query": "404"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/http-status-codes \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"404"}'

const response = await fetch("https://toolforte.com/api/v1/tools/http-status-codes", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "query": "404"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/http-status-codes",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"query":"404"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_color (Color) with color: #c5f04a.

The assistant then makes this tool call:

{
  "name": "convert_color",
  "arguments": {
    "color": "#c5f04a"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/color-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"color":"#c5f04a"}'

const response = await fetch("https://toolforte.com/api/v1/tools/color-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "color": "#c5f04a"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/color-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"color":"#c5f04a"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool color_contrast (Color Contrast) with foreground: #1e293b, background: #ffffff.

The assistant then makes this tool call:

{
  "name": "color_contrast",
  "arguments": {
    "foreground": "#1e293b",
    "background": "#ffffff"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/color-contrast-checker \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"foreground":"#1e293b","background":"#ffffff"}'

const response = await fetch("https://toolforte.com/api/v1/tools/color-contrast-checker", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "foreground": "#1e293b",
    "background": "#ffffff"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/color-contrast-checker",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"foreground":"#1e293b","background":"#ffffff"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool password_strength (Password Strength) with password: correct-horse-battery-staple.

The assistant then makes this tool call:

{
  "name": "password_strength",
  "arguments": {
    "password": "correct-horse-battery-staple"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/password-strength \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"password":"correct-horse-battery-staple"}'

const response = await fetch("https://toolforte.com/api/v1/tools/password-strength", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "password": "correct-horse-battery-staple"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/password-strength",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"password":"correct-horse-battery-staple"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_password (Password) with length: 16, uppercase: true, lowercase: true, numbers: true, symbols: true, excludeAmbiguous: false, count: 1.

The assistant then makes this tool call:

{
  "name": "generate_password",
  "arguments": {
    "length": 16,
    "uppercase": true,
    "lowercase": true,
    "numbers": true,
    "symbols": true,
    "excludeAmbiguous": false,
    "count": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/password-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"length":16,"uppercase":true,"lowercase":true,"numbers":true,"symbols":true,"excludeAmbiguous":false,"count":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/password-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "length": 16,
    "uppercase": true,
    "lowercase": true,
    "numbers": true,
    "symbols": true,
    "excludeAmbiguous": false,
    "count": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/password-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"length":16,"uppercase":true,"lowercase":true,"numbers":true,"symbols":true,"excludeAmbiguous":false,"count":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool validate_email (Email) with email: user@gmial.com.

The assistant then makes this tool call:

{
  "name": "validate_email",
  "arguments": {
    "email": "user@gmial.com"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/email-validator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email":"user@gmial.com"}'

const response = await fetch("https://toolforte.com/api/v1/tools/email-validator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "email": "user@gmial.com"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/email-validator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"email":"user@gmial.com"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool validate_iban (IBAN) with iban: NL91 ABNA 0417 1643 00.

The assistant then makes this tool call:

{
  "name": "validate_iban",
  "arguments": {
    "iban": "NL91 ABNA 0417 1643 00"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/iban-validator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"iban":"NL91 ABNA 0417 1643 00"}'

const response = await fetch("https://toolforte.com/api/v1/tools/iban-validator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "iban": "NL91 ABNA 0417 1643 00"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/iban-validator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"iban":"NL91 ABNA 0417 1643 00"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool calculate_vat (VAT) with amount: 100, rate: 21, mode: add.

The assistant then makes this tool call:

{
  "name": "calculate_vat",
  "arguments": {
    "amount": 100,
    "rate": 21,
    "mode": "add"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/vat-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":100,"rate":21,"mode":"add"}'

const response = await fetch("https://toolforte.com/api/v1/tools/vat-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 100,
    "rate": 21,
    "mode": "add"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/vat-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":100,"rate":21,"mode":"add"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool check_vat_number_format (VAT Number Format Check) with vatNumber: NL123456789B01.

The assistant then makes this tool call:

{
  "name": "check_vat_number_format",
  "arguments": {
    "vatNumber": "NL123456789B01"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/vat-number-check \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"vatNumber":"NL123456789B01"}'

const response = await fetch("https://toolforte.com/api/v1/tools/vat-number-check", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "vatNumber": "NL123456789B01"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/vat-number-check",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"vatNumber":"NL123456789B01"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool percentage (Percentage) with mode: percentOf, x: 15, y: 200.

The assistant then makes this tool call:

{
  "name": "percentage",
  "arguments": {
    "mode": "percentOf",
    "x": 15,
    "y": 200
  }
}

curl -X POST https://toolforte.com/api/v1/tools/percentage-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"mode":"percentOf","x":15,"y":200}'

const response = await fetch("https://toolforte.com/api/v1/tools/percentage-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "mode": "percentOf",
    "x": 15,
    "y": 200
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/percentage-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"mode":"percentOf","x":15,"y":200},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool compound_interest (Compound Interest) with principal: 10000, annualRatePercent: 7, years: 10, compoundsPerYear: 12, monthlyContribution: 100.

The assistant then makes this tool call:

{
  "name": "compound_interest",
  "arguments": {
    "principal": 10000,
    "annualRatePercent": 7,
    "years": 10,
    "compoundsPerYear": 12,
    "monthlyContribution": 100
  }
}

curl -X POST https://toolforte.com/api/v1/tools/compound-interest-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"principal":10000,"annualRatePercent":7,"years":10,"compoundsPerYear":12,"monthlyContribution":100}'

const response = await fetch("https://toolforte.com/api/v1/tools/compound-interest-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "principal": 10000,
    "annualRatePercent": 7,
    "years": 10,
    "compoundsPerYear": 12,
    "monthlyContribution": 100
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/compound-interest-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"principal":10000,"annualRatePercent":7,"years":10,"compoundsPerYear":12,"monthlyContribution":100},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool loan_payment (Loan) with amount: 250000, annualRatePercent: 4.5, term: 30, termUnit: years.

The assistant then makes this tool call:

{
  "name": "loan_payment",
  "arguments": {
    "amount": 250000,
    "annualRatePercent": 4.5,
    "term": 30,
    "termUnit": "years"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/loan-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":250000,"annualRatePercent":4.5,"term":30,"termUnit":"years"}'

const response = await fetch("https://toolforte.com/api/v1/tools/loan-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 250000,
    "annualRatePercent": 4.5,
    "term": 30,
    "termUnit": "years"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/loan-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":250000,"annualRatePercent":4.5,"term":30,"termUnit":"years"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool discount (Discount) with price: 80, discountPercent: 25, additionalDiscountPercents: [10], vatPercent: 21.

The assistant then makes this tool call:

{
  "name": "discount",
  "arguments": {
    "price": 80,
    "discountPercent": 25,
    "additionalDiscountPercents": [
      10
    ],
    "vatPercent": 21
  }
}

curl -X POST https://toolforte.com/api/v1/tools/discount-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"price":80,"discountPercent":25,"additionalDiscountPercents":[10],"vatPercent":21}'

const response = await fetch("https://toolforte.com/api/v1/tools/discount-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "price": 80,
    "discountPercent": 25,
    "additionalDiscountPercents": [
      10
    ],
    "vatPercent": 21
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/discount-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"price":80,"discountPercent":25,"additionalDiscountPercents":[10],"vatPercent":21},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool split_tip (Tip) with bill: 86.4, tipPercent: 15, people: 4, roundUp: false.

The assistant then makes this tool call:

{
  "name": "split_tip",
  "arguments": {
    "bill": 86.4,
    "tipPercent": 15,
    "people": 4,
    "roundUp": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/tip-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"bill":86.4,"tipPercent":15,"people":4,"roundUp":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/tip-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "bill": 86.4,
    "tipPercent": 15,
    "people": 4,
    "roundUp": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/tip-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"bill":86.4,"tipPercent":15,"people":4,"roundUp":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool roi (ROI) with invested: 10000, returned: 14000, years: 3.

The assistant then makes this tool call:

{
  "name": "roi",
  "arguments": {
    "invested": 10000,
    "returned": 14000,
    "years": 3
  }
}

curl -X POST https://toolforte.com/api/v1/tools/roi-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"invested":10000,"returned":14000,"years":3}'

const response = await fetch("https://toolforte.com/api/v1/tools/roi-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "invested": 10000,
    "returned": 14000,
    "years": 3
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/roi-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"invested":10000,"returned":14000,"years":3},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool break_even (Break-even) with fixedCosts: 5000, variableCostPerUnit: 10, pricePerUnit: 25, volume: 500.

The assistant then makes this tool call:

{
  "name": "break_even",
  "arguments": {
    "fixedCosts": 5000,
    "variableCostPerUnit": 10,
    "pricePerUnit": 25,
    "volume": 500
  }
}

curl -X POST https://toolforte.com/api/v1/tools/break-even-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"fixedCosts":5000,"variableCostPerUnit":10,"pricePerUnit":25,"volume":500}'

const response = await fetch("https://toolforte.com/api/v1/tools/break-even-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "fixedCosts": 5000,
    "variableCostPerUnit": 10,
    "pricePerUnit": 25,
    "volume": 500
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/break-even-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"fixedCosts":5000,"variableCostPerUnit":10,"pricePerUnit":25,"volume":500},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_inheritance_tax (Dutch Inheritance Tax) with amount: 100000, heir: child.

The assistant then makes this tool call:

{
  "name": "dutch_inheritance_tax",
  "arguments": {
    "amount": 100000,
    "heir": "child"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/erfbelasting-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":100000,"heir":"child"}'

const response = await fetch("https://toolforte.com/api/v1/tools/erfbelasting-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 100000,
    "heir": "child"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/erfbelasting-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":100000,"heir":"child"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_gift_tax (Dutch Gift Tax) with amount: 25000, relationship: child, exemption: annual.

The assistant then makes this tool call:

{
  "name": "dutch_gift_tax",
  "arguments": {
    "amount": 25000,
    "relationship": "child",
    "exemption": "annual"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/schenkbelasting-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":25000,"relationship":"child","exemption":"annual"}'

const response = await fetch("https://toolforte.com/api/v1/tools/schenkbelasting-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "amount": 25000,
    "relationship": "child",
    "exemption": "annual"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/schenkbelasting-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"amount":25000,"relationship":"child","exemption":"annual"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_ww_duration (Dutch WW Duration) with birthYear: 1975, workedYearsSince1998: 20.

The assistant then makes this tool call:

{
  "name": "dutch_ww_duration",
  "arguments": {
    "birthYear": 1975,
    "workedYearsSince1998": 20
  }
}

curl -X POST https://toolforte.com/api/v1/tools/ww-duration-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"birthYear":1975,"workedYearsSince1998":20}'

const response = await fetch("https://toolforte.com/api/v1/tools/ww-duration-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "birthYear": 1975,
    "workedYearsSince1998": 20
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/ww-duration-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"birthYear":1975,"workedYearsSince1998":20},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_30_percent_ruling (30% Ruling) with grossAnnualSalary: 70000, youngMaster: false.

The assistant then makes this tool call:

{
  "name": "dutch_30_percent_ruling",
  "arguments": {
    "grossAnnualSalary": 70000,
    "youngMaster": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/30-percent-ruling-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"grossAnnualSalary":70000,"youngMaster":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/30-percent-ruling-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "grossAnnualSalary": 70000,
    "youngMaster": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/30-percent-ruling-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"grossAnnualSalary":70000,"youngMaster":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_holiday_allowance (Dutch Holiday Allowance) with monthlySalary: 3500, monthsWorked: 12, allowancePercent: 8, specialRatePercent: 42.01.

The assistant then makes this tool call:

{
  "name": "dutch_holiday_allowance",
  "arguments": {
    "monthlySalary": 3500,
    "monthsWorked": 12,
    "allowancePercent": 8,
    "specialRatePercent": 42.01
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-holiday-allowance-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"monthlySalary":3500,"monthsWorked":12,"allowancePercent":8,"specialRatePercent":42.01}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-holiday-allowance-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "monthlySalary": 3500,
    "monthsWorked": 12,
    "allowancePercent": 8,
    "specialRatePercent": 42.01
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-holiday-allowance-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"monthlySalary":3500,"monthsWorked":12,"allowancePercent":8,"specialRatePercent":42.01},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_severance (Dutch Severance) with monthlySalary: 3500, fixedAnnualBonuses: 0, includeHolidayAllowance: true, startDate: 2018-01-01, endDate: 2026-12-31.

The assistant then makes this tool call:

{
  "name": "dutch_severance",
  "arguments": {
    "monthlySalary": 3500,
    "fixedAnnualBonuses": 0,
    "includeHolidayAllowance": true,
    "startDate": "2018-01-01",
    "endDate": "2026-12-31"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-severance-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"monthlySalary":3500,"fixedAnnualBonuses":0,"includeHolidayAllowance":true,"startDate":"2018-01-01","endDate":"2026-12-31"}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-severance-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "monthlySalary": 3500,
    "fixedAnnualBonuses": 0,
    "includeHolidayAllowance": true,
    "startDate": "2018-01-01",
    "endDate": "2026-12-31"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-severance-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"monthlySalary":3500,"fixedAnnualBonuses":0,"includeHolidayAllowance":true,"startDate":"2018-01-01","endDate":"2026-12-31"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_mileage_allowance (Dutch Mileage Allowance) with kmPerTrip: 25, tripsPerWeek: 8, kmPerWeek: 200, weeksPerYear: 46, ratePerKm: 0.25.

The assistant then makes this tool call:

{
  "name": "dutch_mileage_allowance",
  "arguments": {
    "kmPerTrip": 25,
    "tripsPerWeek": 8,
    "kmPerWeek": 200,
    "weeksPerYear": 46,
    "ratePerKm": 0.25
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-mileage-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"kmPerTrip":25,"tripsPerWeek":8,"kmPerWeek":200,"weeksPerYear":46,"ratePerKm":0.25}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-mileage-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "kmPerTrip": 25,
    "tripsPerWeek": 8,
    "kmPerWeek": 200,
    "weeksPerYear": 46,
    "ratePerKm": 0.25
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-mileage-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"kmPerTrip":25,"tripsPerWeek":8,"kmPerWeek":200,"weeksPerYear":46,"ratePerKm":0.25},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_public_holidays (Dutch Public Holidays) with year: 2026.

The assistant then makes this tool call:

{
  "name": "dutch_public_holidays",
  "arguments": {
    "year": 2026
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-holidays \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"year":2026}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-holidays", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "year": 2026
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-holidays",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"year":2026},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool working_days_between (Working Days) with start: 2026-01-01, end: 2026-01-31, excludeDutchHolidays: true.

The assistant then makes this tool call:

{
  "name": "working_days_between",
  "arguments": {
    "start": "2026-01-01",
    "end": "2026-01-31",
    "excludeDutchHolidays": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/working-days \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"start":"2026-01-01","end":"2026-01-31","excludeDutchHolidays":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/working-days", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "start": "2026-01-01",
    "end": "2026-01-31",
    "excludeDutchHolidays": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/working-days",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"start":"2026-01-01","end":"2026-01-31","excludeDutchHolidays":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_timestamp (Timestamp) with value: 1725710400, unit: auto.

The assistant then makes this tool call:

{
  "name": "convert_timestamp",
  "arguments": {
    "value": 1725710400,
    "unit": "auto"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/timestamp-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":1725710400,"unit":"auto"}'

const response = await fetch("https://toolforte.com/api/v1/tools/timestamp-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": 1725710400,
    "unit": "auto"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/timestamp-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":1725710400,"unit":"auto"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool date_difference (Date Difference) with startDate: 2026-01-01, endDate: 2026-12-31, includeEndDate: false.

The assistant then makes this tool call:

{
  "name": "date_difference",
  "arguments": {
    "startDate": "2026-01-01",
    "endDate": "2026-12-31",
    "includeEndDate": false
  }
}

curl -X POST https://toolforte.com/api/v1/tools/date-difference-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"startDate":"2026-01-01","endDate":"2026-12-31","includeEndDate":false}'

const response = await fetch("https://toolforte.com/api/v1/tools/date-difference-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "startDate": "2026-01-01",
    "endDate": "2026-12-31",
    "includeEndDate": false
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/date-difference-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"startDate":"2026-01-01","endDate":"2026-12-31","includeEndDate":false},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool age (Age) with birthDate: 1990-05-15, asOf: 2026-09-07.

The assistant then makes this tool call:

{
  "name": "age",
  "arguments": {
    "birthDate": "1990-05-15",
    "asOf": "2026-09-07"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/age-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"birthDate":"1990-05-15","asOf":"2026-09-07"}'

const response = await fetch("https://toolforte.com/api/v1/tools/age-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "birthDate": "1990-05-15",
    "asOf": "2026-09-07"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/age-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"birthDate":"1990-05-15","asOf":"2026-09-07"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool week_number (Week Number) with date: 2026-09-07.

The assistant then makes this tool call:

{
  "name": "week_number",
  "arguments": {
    "date": "2026-09-07"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/week-number \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"date":"2026-09-07"}'

const response = await fetch("https://toolforte.com/api/v1/tools/week-number", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "date": "2026-09-07"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/week-number",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"date":"2026-09-07"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_timezone (Timezone) with dateTime: 2026-03-15T14:30, from: Europe/Amsterdam, to: America/New_York.

The assistant then makes this tool call:

{
  "name": "convert_timezone",
  "arguments": {
    "dateTime": "2026-03-15T14:30",
    "from": "Europe/Amsterdam",
    "to": "America/New_York"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/timezone-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"dateTime":"2026-03-15T14:30","from":"Europe/Amsterdam","to":"America/New_York"}'

const response = await fetch("https://toolforte.com/api/v1/tools/timezone-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "dateTime": "2026-03-15T14:30",
    "from": "Europe/Amsterdam",
    "to": "America/New_York"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/timezone-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"dateTime":"2026-03-15T14:30","from":"Europe/Amsterdam","to":"America/New_York"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool aow_age (AOW Age) with birthDate: 1975-05-12, today: 2026-08-28.

The assistant then makes this tool call:

{
  "name": "aow_age",
  "arguments": {
    "birthDate": "1975-05-12",
    "today": "2026-08-28"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/aow-age-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"birthDate":"1975-05-12","today":"2026-08-28"}'

const response = await fetch("https://toolforte.com/api/v1/tools/aow-age-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "birthDate": "1975-05-12",
    "today": "2026-08-28"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/aow-age-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"birthDate":"1975-05-12","today":"2026-08-28"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_notice_period (Dutch Notice Period) with givenBy: employee, startDate: 2019-03-01, noticeDate: 2026-09-12, contractMonths: 1.

The assistant then makes this tool call:

{
  "name": "dutch_notice_period",
  "arguments": {
    "givenBy": "employee",
    "startDate": "2019-03-01",
    "noticeDate": "2026-09-12",
    "contractMonths": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-notice-period-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"givenBy":"employee","startDate":"2019-03-01","noticeDate":"2026-09-12","contractMonths":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-notice-period-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "givenBy": "employee",
    "startDate": "2019-03-01",
    "noticeDate": "2026-09-12",
    "contractMonths": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-notice-period-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"givenBy":"employee","startDate":"2019-03-01","noticeDate":"2026-09-12","contractMonths":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool dutch_school_holidays (Dutch School Holidays) with schoolYear: 2026-2027, region: midden, today: 2026-09-07.

The assistant then makes this tool call:

{
  "name": "dutch_school_holidays",
  "arguments": {
    "schoolYear": "2026-2027",
    "region": "midden",
    "today": "2026-09-07"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/dutch-school-holidays \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"schoolYear":"2026-2027","region":"midden","today":"2026-09-07"}'

const response = await fetch("https://toolforte.com/api/v1/tools/dutch-school-holidays", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "schoolYear": "2026-2027",
    "region": "midden",
    "today": "2026-09-07"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/dutch-school-holidays",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"schoolYear":"2026-2027","region":"midden","today":"2026-09-07"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool bmi (BMI) with height: 175, weight: 70, units: metric.

The assistant then makes this tool call:

{
  "name": "bmi",
  "arguments": {
    "height": 175,
    "weight": 70,
    "units": "metric"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/bmi-calculator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"height":175,"weight":70,"units":"metric"}'

const response = await fetch("https://toolforte.com/api/v1/tools/bmi-calculator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "height": 175,
    "weight": 70,
    "units": "metric"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/bmi-calculator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"height":175,"weight":70,"units":"metric"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool px_to_rem (PX to REM) with value: 24, direction: px-to-rem, rootFontSize: 16.

The assistant then makes this tool call:

{
  "name": "px_to_rem",
  "arguments": {
    "value": 24,
    "direction": "px-to-rem",
    "rootFontSize": 16
  }
}

curl -X POST https://toolforte.com/api/v1/tools/px-rem-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":24,"direction":"px-to-rem","rootFontSize":16}'

const response = await fetch("https://toolforte.com/api/v1/tools/px-rem-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": 24,
    "direction": "px-to-rem",
    "rootFontSize": 16
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/px-rem-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":24,"direction":"px-to-rem","rootFontSize":16},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool convert_units (Unit) with value: 10, from: km, to: mi, category: length.

The assistant then makes this tool call:

{
  "name": "convert_units",
  "arguments": {
    "value": 10,
    "from": "km",
    "to": "mi",
    "category": "length"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/unit-converter \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value":10,"from":"km","to":"mi","category":"length"}'

const response = await fetch("https://toolforte.com/api/v1/tools/unit-converter", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "value": 10,
    "from": "km",
    "to": "mi",
    "category": "length"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/unit-converter",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"value":10,"from":"km","to":"mi","category":"length"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_test_bsn (Test BSN) with count: 5.

The assistant then makes this tool call:

{
  "name": "generate_test_bsn",
  "arguments": {
    "count": 5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/test-bsn-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"count":5}'

const response = await fetch("https://toolforte.com/api/v1/tools/test-bsn-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "count": 5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/test-bsn-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"count":5},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_test_iban (Test IBAN) with count: 5, country: NL.

The assistant then makes this tool call:

{
  "name": "generate_test_iban",
  "arguments": {
    "count": 5,
    "country": "NL"
  }
}

curl -X POST https://toolforte.com/api/v1/tools/test-iban-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"count":5,"country":"NL"}'

const response = await fetch("https://toolforte.com/api/v1/tools/test-iban-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "count": 5,
    "country": "NL"
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/test-iban-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"count":5,"country":"NL"},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_brp_test_data (BRP Test Data) with format: json, options: {"count":3,"seed":42}.

The assistant then makes this tool call:

{
  "name": "generate_brp_test_data",
  "arguments": {
    "format": "json",
    "options": {
      "count": 3,
      "seed": 42
    }
  }
}

curl -X POST https://toolforte.com/api/v1/tools/brp-test-data-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format":"json","options":{"count":3,"seed":42}}'

const response = await fetch("https://toolforte.com/api/v1/tools/brp-test-data-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "format": "json",
    "options": {
      "count": 3,
      "seed": 42
    }
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/brp-test-data-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"format":"json","options":{"count":3,"seed":42}},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_upa_files (UPA File) with format: summary, options: {"population":{"count":3}}.

The assistant then makes this tool call:

{
  "name": "generate_upa_files",
  "arguments": {
    "format": "summary",
    "options": {
      "population": {
        "count": 3
      }
    }
  }
}

curl -X POST https://toolforte.com/api/v1/tools/upa-file-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format":"summary","options":{"population":{"count":3}}}'

const response = await fetch("https://toolforte.com/api/v1/tools/upa-file-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "format": "summary",
    "options": {
      "population": {
        "count": 3
      }
    }
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/upa-file-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"format":"summary","options":{"population":{"count":3}}},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_lorem_ipsum (Lorem Ipsum) with count: 2, type: sentences, startWithLorem: true, html: false, seed: 1.

The assistant then makes this tool call:

{
  "name": "generate_lorem_ipsum",
  "arguments": {
    "count": 2,
    "type": "sentences",
    "startWithLorem": true,
    "html": false,
    "seed": 1
  }
}

curl -X POST https://toolforte.com/api/v1/tools/lorem-ipsum-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"count":2,"type":"sentences","startWithLorem":true,"html":false,"seed":1}'

const response = await fetch("https://toolforte.com/api/v1/tools/lorem-ipsum-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "count": 2,
    "type": "sentences",
    "startWithLorem": true,
    "html": false,
    "seed": 1
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/lorem-ipsum-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"count":2,"type":"sentences","startWithLorem":true,"html":false,"seed":1},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool random_numbers (Random Number) with min: 1, max: 6, count: 3, allowDuplicates: true.

The assistant then makes this tool call:

{
  "name": "random_numbers",
  "arguments": {
    "min": 1,
    "max": 6,
    "count": 3,
    "allowDuplicates": true
  }
}

curl -X POST https://toolforte.com/api/v1/tools/random-number-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"min":1,"max":6,"count":3,"allowDuplicates":true}'

const response = await fetch("https://toolforte.com/api/v1/tools/random-number-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "min": 1,
    "max": 6,
    "count": 3,
    "allowDuplicates": true
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/random-number-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"min":1,"max":6,"count":3,"allowDuplicates":true},
)
result = response.json()  # {"ok": true, "data": {...}}

With the server connected, say something like:

Use the ToolForte tool generate_test_document_number (Test Document Number) with type: idkaart, count: 5.

The assistant then makes this tool call:

{
  "name": "generate_test_document_number",
  "arguments": {
    "type": "idkaart",
    "count": 5
  }
}

curl -X POST https://toolforte.com/api/v1/tools/test-documentnummer-generator \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"type":"idkaart","count":5}'

const response = await fetch("https://toolforte.com/api/v1/tools/test-documentnummer-generator", {
  method: "POST",
  headers: {
    Authorization: "Bearer YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    "type": "idkaart",
    "count": 5
  }),
});
const { ok, data, error } = await response.json();

import requests

response = requests.post(
    "https://toolforte.com/api/v1/tools/test-documentnummer-generator",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"type":"idkaart","count":5},
)
result = response.json()  # {"ok": true, "data": {...}}