Microfn Blog

How to add microfn to Claude Code

Microfn — Tue, 17 Feb 2026 00:00:00 GMT

Give Claude Code a persistent, self-evolving toolkit. Add microfn as a plugin and Claude Code can create custom functions, update them as needs change, and build a reusable library—all deployed instantly to a secure sandbox.

Build tools once, then refine them. Every function persists across sessions, ready to be patched, composed, and evolved.

1. Install via CLI

Run the following commands to add and enable microfn:

claude plugin marketplace add microfnhq/skills
claude plugin enable microfn

Or: Enable via `/plugin` command

Instead of running claude plugin enable microfn, you can type /plugin inside a Claude Code session and follow the prompts to enable microfn.

2. Authenticate

When you first run a command using the microfn server, you will be prompted to authenticate via OAuth in your browser.

For more details on available tools and advanced configuration, check out the microfn MCP documentation.

Built with microfn, your toolbox for composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it instantly.

How to add microfn to ChatGPT

Microfn — Mon, 16 Feb 2026 00:00:00 GMT

Turn ChatGPT into a tool-building agent with its own persistent arsenal. With microfn's MCP integration, ChatGPT creates reusable functions that it can update, patch, and evolve—not just one-off code execution.

Each function becomes part of ChatGPT's growing toolbox, deployed instantly to a secure cloud environment and ready to reuse across conversations.

1. Access settings

Navigate to chatgpt.com/apps#settings/Connectors/Advanced.

2. Enable Developer Mode

In the Advanced settings, ensure Developer Mode is toggled ON.

3. Create MCP Server

Click the Create button (often labeled as "Create App" in the developer view) to add a new MCP Server.

Fill in the following details:

Name: microfn
Server URL: https://mcp.microfn.dev/mcp
Authentication: OAuth
Trust: Toggle I trust this application to ON.

4. Connect and Authorize

Click Save, then find microfn in your list of servers and click Connect.

You will be redirected to authorize the connection via OAuth. Follow the prompts to log in to your microfn account and authorize the integration.

5. Verify

To use microfn in a new chat, ensure it is enabled in the model selector.

Once enabled, you can verify the integration by asking ChatGPT to run a command, like "whoami".

For more details on available tools and advanced configuration, check out the microfn MCP documentation.

Built with microfn, your toolbox for composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it instantly.

How to add microfn to Claude

Microfn — Mon, 16 Feb 2026 00:00:00 GMT

Give Claude its own evolving toolbox. Connect microfn via MCP and Claude can create, update, and reuse custom JavaScript functions—building a persistent library of tools that grows smarter over time.

Build a weather function once, then refine it. Create an API integration, then patch it when requirements change. Every tool runs instantly in a secure sandbox and stays ready for the next conversation.

1. Access settings

Navigate to your Claude.ai connector settings.

2. Add Custom Connector

Click the Add Custom Connector button and fill out the form with the following details:

Name: microfn
Remote URL: https://mcp.microfn.dev/mcp

3. Connect and Authorize

After adding it, find microfn in your connectors list and click Connect.

You will be prompted to authorize the connection via OAuth. Simply follow the browser prompts to log in and grant access to your microfn account.

4. Verify

Once connected, you can verify the integration by asking Claude to run a command. For example, ask "whoami" to see your microfn user details.

You can also ask Claude to call any of your microfn functions directly.

For more details on available tools and advanced configuration, check out the microfn MCP documentation.

Built with microfn, your toolbox for composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it instantly.

Extending OpenClaw with Microfn Skills

Microfn — Mon, 16 Feb 2026 00:00:00 GMT

Give OpenClaw its own persistent toolkit. Connect microfn and your agent can create reusable functions, update them as needs change, and build a growing library of custom capabilities.

Build tools once, then reuse them. Need to change the logic? Patch existing functions. New integration? Compose existing tools or create new ones. All running securely in microfn's cloud sandbox.

1. Install the Microfn Skill

To get started, you need to tell OpenClaw to install the Microfn skill. You can do this by pointing it to the official skills repository:

"Install the microfn skill from github.com/microfnhq/skills"

2. Generate an API Token

OpenClaw needs to authenticate with Microfn to deploy and run your functions.

Go to your Microfn API settings.
Generate a new API Token.
Copy the token; you'll need to give it to OpenClaw in the next step.

3. Configure OpenClaw

Once you have your token, tell OpenClaw to save it securely:

"Use my microfn API token: <YOUR_TOKEN>"

OpenClaw will store this token and use it to communicate with the Microfn cloud.

4. Building Tools on the Fly

Now that OpenClaw is connected, it can build its own tools. You can ask it to perform complex tasks, and it will automatically determine if it needs to create a new function to get the job done.

Example prompts for OpenClaw:

"Create a tool to fetch the current price of Bitcoin and send me a notification if it drops below $50k."
"Write a function to summarize the last 5 emails from my inbox and save the summary to KV storage."
"Build a custom API integration for my internal CRM."

Why use Microfn with OpenClaw?

Secure Sandbox: Code runs in an isolated cloud environment, protecting your local machine.
Persistent Storage: Use built-in KV storage for stateful workflows.
Secrets Management: Safely handle API keys and credentials.
Zero Configuration: Functions are deployed and ready to run instantly.

For more details on building and managing skills, check out the OpenClaw documentation.

Built with microfn, your toolbox for composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it instantly.

How to add microfn to OpenAI Codex

Microfn — Mon, 16 Feb 2026 00:00:00 GMT

Give Codex a persistent, self-evolving toolkit. Add microfn as an MCP server and Codex can create custom functions, update them as needs change, and build a reusable library—all deployed instantly to a secure sandbox.

Build tools once, then refine them. Every function persists across sessions, ready to be patched, composed, and evolved.

1. Install via CLI

Run the following command to add microfn as an MCP server:

codex mcp add microfn --url https://mcp.microfn.dev/mcp

Or: Edit configuration manually

Open ~/.codex/config.toml in your preferred editor. If it doesn't exist, you can create it.

Add the following [mcp_servers.microfn] block to the file:

[mcp_servers.microfn]
url = "https://mcp.microfn.dev/mcp"

3. Authenticate

When you first run a command using the microfn server, you will be prompted to authenticate via OAuth in your browser.

For more details on available tools and advanced configuration, check out the microfn MCP documentation.

Built with microfn, your toolbox for composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it instantly.

Connecting GitHub notifications to Discord or Slack in less than 5 minutes with microfn

Microfn — Fri, 26 Sep 2025 00:00:00 GMT

In today’s guide we’ll hook GitHub repository events into Discord (or Slack) using microfn.

It only takes a few minutes to capture GitHub webhooks in a function and relay the highlights to the chat channel your team actually watches.

1. Create a microfn account

If you don’t have one yet, head to https://microfn.dev. Sign up for free—no credit card required.

2. Create a new function

Tap the “+” button in the top-left to create a function. Give it a descriptive name like github-notifier, or fork an existing notifier if you already have one in your workspace.

After saving, open the Triggers tab and copy the webhook URL. It looks like https://microfn.dev/run/:username/:functionName.

3. Connect the function to GitHub

In GitHub, open the repository you want to monitor and navigate to Settings → Webhooks. Paste the microfn URL into the webhook target field (https://microfn.dev/run/:username/:functionName) and keep the default application/json content type.

Choose the events you care about (start with “Just the push event” if you’re not sure), then hit Add webhook.

4. Check the GitHub webhook that arrived at your function

Head back to microfn, select your function, and open the Executions tab. You should see the incoming GitHub webhook, complete with its JSON payload.

Click Replay to resend the event while you iterate and add downstream actions.

5. Forward alerts to Discord or Slack

Use the webhook payload to craft a message, then hand it off to a reusable notifier function.

import fn from '@microfn/fn';

export async function main(input) {
  const payload = input.body ?? input;
  const repo = payload.repository?.full_name ?? 'unknown-repo';
  const actor = payload.sender?.login ?? 'someone';
  const branch = payload.ref?.split('/')?.at(-1) ?? 'main';
  const commits = (payload.commits ?? [])
    .map((commit) => `• ${commit.message}`)
    .join('\n');

  const message = `🔔 ${actor} pushed to ${repo}/${branch}` + (commits ? `\n${commits}` : '');

  await fn.executeFunction('david/send-discord-message', {
    channelId: process.env.DISCORD_CHANNEL_ID,
    content: message
  });

  return { status: 'delivered' };
}

Store DISCORD_CHANNEL_ID as a secret or environment variable in microfn. When a push arrives, the helper function handles Discord authentication and posting.

Need the helper? You can fork david/send-discord-message, or drop in the implementation below:

import secret from '@microfn/secret';

export async function main(input) {
  const token = await secret.getRequired('DISCORD_BOT_TOKEN');

  let actualInput = input;
  if (actualInput.input) {
    actualInput = actualInput.input;
  }

  const { channelId, content } = actualInput;

  const response = await fetch(
    `https://discord.com/api/v10/channels/${channelId}/messages`,
    {
      method: 'POST',
      headers: {
        Authorization: `Bot ${token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ content })
    }
  );

  const data = await response.json();
  if (!response.ok) {
    throw new Error(
      `Discord API error: ${response.status} ${JSON.stringify(data)}`
    );
  }

  return data;
}

Swap in Slack by calling your Slack webhook instead, or branch on the payload to send to both platforms.

Built in microfn, your toolbox for small composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it anywhere you need it.

Start for free—no credit card required!

How to quickly act on incoming emails with microfn

Microfn — Wed, 24 Sep 2025 00:00:00 GMT

Microfn comes with a built-in email connector, so you can forward any message into a function and respond automatically.

With a few clicks you can triage, forward, or archive email directly from a microfn workflow. Here’s how to wire it up:

1. Create a new function

In microfn, tap the “+” button to create a new function and give it a name that matches the job you want it to do.

export async function main(input) {
  return {
    message: "Hello from Microfn!",
    timestamp: new Date().toISOString(),
    receivedInput: input
  };
}

2. Enable the Email trigger

Once the function is saved, open the Triggers tab and enable the Email Trigger.

The email trigger generates a unique address for your function. Every message sent to that inbox calls your function with the email’s contents.

Need more detail? Check out the Microfn email trigger docs.

Microfn also adds a new email() export to your workspace so each incoming message is dispatched automatically. Here’s a complete example you can drop into a new function:

export async function main(input) {
  return {
    message: "Hello from Microfn!",
    timestamp: new Date().toISOString(),
    receivedInput: input
  };
}

export async function email(emailPayload) {
  // handle email trigger
  console.log("email received");
  console.log(emailPayload);

  return {
    status: "processed",
    receivedSubject: emailPayload.email.subject
  };
}

2.1 Check executions for incoming email data

Send a message to the generated address and watch it appear in the Executions panel.

Hit Replay to resend the same payload while you iterate, so you can verify your function behaves the way you expect.

3. Forward, categorize, save

From here, the workflow is yours to design—forward high-priority mail to Discord, store attachments in cloud storage, or build filters that only alert you when it matters.

Email trigger input shape

Here’s an example payload delivered to email() when a message arrives:

{
  "email": {
    "body": "Hi team, we just received a new inbound lead from the website. Can you follow up today?",
    "from": "alerts@example.com",
    "rawSize": 4821,
    "subject": "New lead: Acme Corp",
    "timestamp": "2025-09-20T15:46:14.515Z",
    "to": "fn-cdmixwn7kw7p@mail.microfn.dev"
  }
}

Built with microfn, your toolbox for composable functions

Microfn is a tiny cloud runner for composable JavaScript functions. Write your function, hit save, and microfn deploys it instantly.

Ready to automate your inbox? Get started for free—no credit card required.

How to call microfn functions from other functions

Microfn — Mon, 22 Sep 2025 00:00:00 GMT

Microfn supports cross-function calls, so your functions can call other functions.

This makes it possible to create reusable functions that you can plug into all kinds of scenarios.

For example, you could have a send-discord-message function that is responsible for sending a message to Discord and use it across every other function you’d like to hook up to Discord.

Here’s how it works:

1. Create a new function

Head to https://microfn.dev and tap the “+” button to create a new function. Give it a nice name.

export async function main(input) {
  return {
    message: "Hello there, I'm a function!",
    timestamp: new Date().toISOString(),
    receivedInput: input
  };
}

2. Import the @microfn/fn module

In your function, add our @microfn/fn module. This is a built-in module provided by microfnhq to facilitate cross-function calls.

import fn from '@microfn/fn'

3. Use fn to send data between your functions

import fn from "@microfn/fn";

export async function main(input) {
  const res = await fn.executeFunction("david/call-me", "foobar");

  return {
    message: "Hello there, I'm the main function",
    timestamp: new Date().toISOString(),
    receivedOutput: res
  };
}

4. Call your function

Calling the function gives us the following output:

{
  "message": "Hello there, I'm the main function",
  "receivedOutput": {
    "message": "Hello there, I'm a function!",
    "receivedInput": {
      "input": "foobar"
    },
    "timestamp": "2025-09-22T08:00:52.972Z"
  },
  "timestamp": "2025-09-22T08:00:53.175Z"
}

Caveats

Only cross-calls across your account are currently supported. You will not be able to call functions not owned by you.

Check out the full documentation of the @microfn/fn module at https://docs.microfn.dev/modules/fn/

How to turn Any JavaScript Function Into a MCP Tool

Microfn — Sun, 20 Jul 2025 00:00:00 GMT

In today's guide, we explain how to use microfn to turn any JavaScript or TypeScript function into a MCP tool that can be plugged into your favorite agent.

Getting started

First, let's figure out what our new MCP tool should do. For this guide, I thought it would be interesting to create a tool that can store memory for the agent in the cloud, so we can use the same memory storage across differnt agents.

Let's scaffold something quick. We can also ask AI directly to do this for us using the microfn MCP.

import kv from "@microfn/kv";

const MEMORY_KEY = "mcp-memory";

// Helper to get all memories from the KV store
async function getMemories(): Promise<Record<string, any>> {
  const memories = await kv.get<Record<string, any>>(MEMORY_KEY);
  return memories || {};
}

// Helper to save all memories to the KV store
async function saveMemories(memories: Record<string, any>) {
  await kv.set(MEMORY_KEY, memories);
}

// --- Command Functions ---

async function listAllMemories() {
  console.log("Fetching all memories.");
  const memories = await getMemories();
  console.log(`Found ${Object.keys(memories).length} memories.`);
  return memories;
}

async function createOrUpdateMemory(key: string, value: any) {
  console.log(`Creating/updating memory for key: '${key}'.`);
  const memories = await getMemories();
  memories[key] = value;
  await saveMemories(memories);
  console.log(`Memory for '${key}' successfully saved.`);
  return { success: true, message: `Memory '${key}' has been created/updated.` };
}

async function deleteMemory(key: string) {
  console.log(`Attempting to delete memory with key: '${key}'.`);
  const memories = await getMemories();
  if (key in memories) {
    delete memories[key];
    await saveMemories(memories);
    console.log(`Memory for '${key}' was deleted.`);
    return { success: true, message: `Memory '${key}' has been deleted.` };
  } else {
    console.log(`Memory with key '${key}' not found.`);
    return { success: false, message: `Memory '${key}' not found.` };
  }
}

// --- Main Handler ---

export async function main(input: { command: "list" | "create" | "delete", key?: string, value?: any }) {
  const { command, key, value } = input;
  console.log(`Command: '${command}'`);

  switch (command) {
    case "list":
      return await listAllMemories();

    case "create":
      if (!key || value === undefined) {
        throw new Error("The 'key' and 'value' parameters are required for the 'create' command.");
      }
      return await createOrUpdateMemory(key, value);

    case "delete":
      if (!key) {
        throw new Error("The 'key' parameter is required for the 'delete' command.");
      }
      return await deleteMemory(key);

    default:
      // This part should be unreachable given the TypeScript type, but it's good practice
      // to have a default case for robustness.
      const exhaustiveCheck: never = command;
      throw new Error(`Unhandled command: ${exhaustiveCheck}`);
  }
}

This function

takes a command, whether to list, create, or delete a memory
persists the memory to kv storage

Because we need some kind of persistence, we'll be using @microfn/kv for this (docs here)

Now let's turn this function into a MCP tool

Deploying the function

If the AI agent hasn't already done it, let's deploy this to the microfn platform and create a new function. We'll call this memory-store

In the editor, paste the code from above and hit save, this will deploy the function onto microfn

Once deployed, we can already play with our new memory store through cURL:

❯ curl -X POST https://microfn.dev/run/david/memory-store -d '{ "command": "list" }'
{}⏎

❯ curl -X POST https://microfn.dev/run/david/memory-store -d '{ "command": "create", "key": "my name", "value": "microfn" }'
{"success":true,"message":"Memory 'my name' has been created/updated."}⏎

❯ curl -X POST https://microfn.dev/run/david/memory-store -d '{ "command": "list" }'
{"my name":"microfn"}⏎

Using our new function through MCP

Setting up the microfn MCP is easy. For most clients we can just do

{
  "mcpServers": {
    "microfn": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.microfn.dev/sse"]
    }
  }
}

For clients that support remote-mcp directly, we can also just use mcp.microfn.dev/sse without mcp-remote. Check out https://microfn.dev/mcp for more info

Once setup, let's ask cloud to use the new store:

Neat!

Teaching Claude to use the new memory store is also super easy:

We can do even better

Currently an agent needs to execute the tool through the executeFunction MCP tool, but we can do better.

Head over to settings and enable "Expose as direct MCP tool"

This will turn our new function into a direct MCP tool, so next time you ask Claude something, it can directly call the function:

Under the hood, microfn created a new function within the MCP server

Give microfn a try

Microfn is available to use for free with a paid plan. Check it out over at https://microfn.dev and let us know what you think!

Microfn Blog

How to add microfn to Claude Code

1. Install via CLI

Or: Enable via /plugin command

2. Authenticate

Read more

Built with microfn, your toolbox for composable functions

How to add microfn to ChatGPT

1. Access settings

2. Enable Developer Mode

3. Create MCP Server

4. Connect and Authorize

5. Verify

Read more

Built with microfn, your toolbox for composable functions

How to add microfn to Claude

1. Access settings

2. Add Custom Connector

3. Connect and Authorize

4. Verify

Read more

Built with microfn, your toolbox for composable functions

Extending OpenClaw with Microfn Skills

1. Install the Microfn Skill

2. Generate an API Token

3. Configure OpenClaw

4. Building Tools on the Fly

Why use Microfn with OpenClaw?

Read more

Built with microfn, your toolbox for composable functions

How to add microfn to OpenAI Codex

1. Install via CLI

Or: Edit configuration manually

3. Authenticate

Read more

Built with microfn, your toolbox for composable functions

Connecting GitHub notifications to Discord or Slack in less than 5 minutes with microfn

1. Create a microfn account

2. Create a new function

3. Connect the function to GitHub

4. Check the GitHub webhook that arrived at your function

5. Forward alerts to Discord or Slack

Built in microfn, your toolbox for small composable functions

How to quickly act on incoming emails with microfn

1. Create a new function

2. Enable the Email trigger

2.1 Check executions for incoming email data

3. Forward, categorize, save

Email trigger input shape

Built with microfn, your toolbox for composable functions

How to call microfn functions from other functions

1. Create a new function

2. Import the @microfn/fn module

3. Use fn to send data between your functions

4. Call your function

Caveats

How to turn Any JavaScript Function Into a MCP Tool

Getting started

Deploying the function

Using our new function through MCP

We can do even better

Give microfn a try

Or: Enable via `/plugin` command