> ## Documentation Index
> Fetch the complete documentation index at: https://docs.modulex.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Browse the integration catalog

> Browse all 175 ModuleX integrations by category, search for a service, and learn how to read a tool's catalog page before you connect it.

export const MediaEmbed = ({id, type = 'screenshot', caption = '', ext, ratio = '16 / 9'}) => {
  const isVideo = type === 'video' || type === 'app_video';
  const resolvedExt = ext || (isVideo ? 'mp4' : type === 'screenshot' ? 'webp' : 'svg');
  const src = 'https://media.modulex.dev/' + id + '.' + resolvedExt;
  const [status, setStatus] = useState('loading');
  const [isDev, setIsDev] = useState(false);
  const [inView, setInView] = useState(false);
  const boxRef = useRef(null);
  useEffect(() => {
    if (typeof window === 'undefined') return;
    const h = window.location.hostname;
    setIsDev(h === 'localhost' || h === '127.0.0.1' || h.endsWith('.mintlify.app'));
  }, []);
  useEffect(() => {
    if (inView) return;
    if (typeof IntersectionObserver === 'undefined') {
      setInView(true);
      return;
    }
    const el = boxRef.current;
    if (!el) return;
    const io = new IntersectionObserver(entries => {
      if (entries.some(e => e.isIntersecting)) {
        setInView(true);
        io.disconnect();
      }
    }, {
      rootMargin: '300px'
    });
    io.observe(el);
    return () => io.disconnect();
  }, [inView]);
  if (status === 'missing') {
    if (!isDev) return null;
    return <div style={{
      display: 'flex',
      flexDirection: 'column',
      justifyContent: 'center',
      gap: '0.4rem',
      padding: '1rem 1.25rem',
      margin: '1.25rem 0',
      width: '100%',
      aspectRatio: ratio,
      boxSizing: 'border-box',
      border: '1px dashed rgba(128,128,128,0.45)',
      borderRadius: '0.75rem',
      background: 'rgba(128,128,128,0.06)',
      color: 'currentColor',
      fontSize: '0.85rem',
      lineHeight: 1.45
    }}>
        <div style={{
      display: 'flex',
      alignItems: 'center',
      gap: '0.5rem',
      opacity: 0.75
    }}>
          <span aria-hidden="true">🎬</span>
          <code style={{
      fontSize: '0.75rem'
    }}>{id}</code>
          <span style={{
      fontSize: '0.65rem',
      textTransform: 'uppercase',
      letterSpacing: '0.04em',
      padding: '0.1rem 0.4rem',
      borderRadius: '0.4rem',
      background: 'rgba(128,128,128,0.18)'
    }}>
            {type}
          </span>
        </div>
        <div style={{
      opacity: 0.9
    }}>{caption || 'Media not uploaded yet.'}</div>
        <div style={{
      fontSize: '0.7rem',
      opacity: 0.5
    }}>
          Upload to R2 as <code>{id}.{resolvedExt}</code> — preview only, hidden in production.
        </div>
      </div>;
  }
  const mediaStyle = {
    display: status === 'loaded' ? 'block' : 'none',
    width: '100%',
    height: 'auto',
    borderRadius: '0.75rem'
  };
  const media = isVideo ? <video src={inView ? src : undefined} autoPlay loop muted playsInline preload="metadata" onLoadedData={() => setStatus('loaded')} onError={() => setStatus('missing')} style={mediaStyle} /> : <img src={inView ? src : undefined} alt={caption} onLoad={() => setStatus('loaded')} onError={() => setStatus('missing')} style={mediaStyle} />;
  return <figure style={{
    margin: '1.25rem 0'
  }}>
      <div ref={boxRef} style={status === 'loaded' ? {
    width: '100%'
  } : {
    width: '100%',
    aspectRatio: ratio,
    borderRadius: '0.75rem',
    background: 'rgba(128,128,128,0.06)'
  }}>
        {media}
      </div>
      {status === 'loaded' && caption ? <figcaption style={{
    marginTop: '0.5rem',
    textAlign: 'center',
    fontSize: '0.85rem',
    opacity: 0.7
  }}>
          {caption}
        </figcaption> : null}
    </figure>;
};

The catalog is the directory of everything ModuleX can connect to. Each entry is an **integration** — a connector to an outside service such as Slack, GitHub, or Salesforce — and each integration exposes one or more **tools**, the individual actions your workflows and the Assistant can call.

ModuleX ships **175 integrations** today. Browse them by category, search for the service you need, then open its page to see what it can do before you connect it.

<Note>
  New to integrations? Start with [the integrations overview](/integrations/overview) for the bigger picture of how connectors, tools, and credentials fit together. This page is for finding a specific integration once you know you want one.
</Note>

## What counts as an integration

An integration packages everything ModuleX needs to talk to one service:

<CardGroup cols={2}>
  <Card title="The connection" icon="plug">
    How ModuleX signs in to the service on your behalf — an API key, an OAuth connection, or a managed key. You set this up once as a credential.
  </Card>

  <Card title="The tools" icon="wrench">
    The individual actions the integration can perform — "send a message", "create an issue", "search records". One integration usually exposes several tools.
  </Card>

  <Card title="The catalog page" icon="file-lines">
    A generated reference page that lists every tool, its inputs, how it authenticates, and any limits — so you know what you are connecting before you connect it.
  </Card>

  <Card title="The logo and details" icon="image">
    The service's display name, logo, and link to its own site, so the catalog stays easy to scan.
  </Card>
</CardGroup>

Once an integration is connected, its tools become available to your workflows through the [Tool node](/workflow-builder/nodes/tool) and to the [Assistant](/assistant/overview) when it works through a task.

## Browse by category

Each integration is tagged with one or more categories so you can scan the catalog by the kind of work you do rather than by remembering exact product names. The largest groups are:

<CardGroup cols={2}>
  <Card title="Productivity & collaboration" icon="users">
    Team and document tools — messaging, calendars, docs, and project trackers. The largest group in the catalog.
  </Card>

  <Card title="Developer tools & infrastructure" icon="terminal">
    Source control, cloud platforms, observability, and deployment services.
  </Card>

  <Card title="Marketing" icon="megaphone">
    Email, campaigns, analytics, and audience tools.
  </Card>

  <Card title="CRM & sales" icon="address-book">
    Customer records, pipelines, and outreach platforms.
  </Card>

  <Card title="Automation" icon="bolt">
    Connectors that move data between other services and trigger downstream work.
  </Card>

  <Card title="Everything else" icon="ellipsis">
    Payments, data warehouses, AI services, support desks, and many more specialised connectors.
  </Card>
</CardGroup>

<Note>
  Categories are a browsing aid, not a fixed taxonomy. Each integration sets its own categories, so the exact labels and counts shift as the catalog grows. Use search when you already know the service you want.
</Note>

<MediaEmbed id="MX-MEDIA-4040" type="screenshot" caption={"The integration catalog in the ModuleX app, showing the category sidebar and a grid of integration cards."} />

## Find an integration

<Steps>
  <Step title="Open the catalog">
    In the app, go to the integrations area and open **Browse**. You'll see every available integration as a card with its logo and a short description.
  </Step>

  <Step title="Search or filter">
    Type the service name in the search box, or pick a category to narrow the grid. Search matches the display name and description, so "email", "calendar", or "database" all surface relevant results.
  </Step>

  <Step title="Open the integration's page">
    Click a card to open its catalog page. Review the tools it exposes and how it authenticates before you connect it.
  </Step>

  <Step title="Connect it">
    Add a credential for the integration, then use its tools from a workflow or the Assistant. See [connect an integration](/guides/connect-an-integration) for the full walkthrough.
  </Step>
</Steps>

## What's on a tool's catalog page

Every integration has its own page, generated directly from the integration's manifest so it always matches what the service actually exposes. When you open one, you'll find:

<AccordionGroup>
  <Accordion title="Header — name, logo, and description" icon="heading">
    The service's display name, logo, a short description of what it does, and a link to the service's own website.
  </Accordion>

  <Accordion title="Tools — the actions you can call" icon="list-check">
    Every tool the integration exposes, each with a plain description, its inputs (name, type, and whether each is required), and the shape of what it returns. This is the menu your workflows and the Assistant choose from.
  </Accordion>

  <Accordion title="Authentication — how to connect" icon="key">
    How the integration signs in — an API key, an OAuth connection, or a ModuleX-managed key — and any setup steps or values you need to provide. See [authentication & credentials](/integrations/authentication) for how each method works.
  </Accordion>

  <Accordion title="Limits & quotas" icon="gauge">
    Service-specific rate limits, size caps, and other constraints to keep in mind, drawn from the integration's own notes.
  </Accordion>

  <Accordion title="Maintainer" icon="user-gear">
    Who maintains the integration. Most are maintained by ModuleX.
  </Accordion>
</AccordionGroup>

<Note>
  Catalog pages are generated from each integration's manifest, not written by hand. If a page looks out of date, the fix is to update the source integration and regenerate — the page will follow.
</Note>

## Browse the catalog from code

You can also list the catalog programmatically — useful for building your own picker or syncing the available integrations into another tool. The browse endpoint returns the integrations available to your organization.

`GET /integrations/browse` is restricted to organization owners and admins, so the API key you use must belong to an owner or admin of the organization.

Every request authenticates with `Authorization: Bearer mx_live_…` plus your `X-Organization-ID`. See [authentication](/api-reference/authentication) for how to get and use these.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.modulex.dev/integrations/browse \
    -H "Authorization: Bearer mx_live_your_api_key" \
    -H "X-Organization-ID: org_your_org_id"
  ```

  ```python Python theme={null}
  import asyncio
  from modulex import Modulex


  async def main():
      async with Modulex(
          api_key="mx_live_your_api_key",
          organization_id="org_your_org_id",
      ) as client:
          catalog = await client.integrations.browse()
          for integration in catalog.integrations:
              print(integration.name, integration.display_name)


  asyncio.run(main())
  ```

  ```javascript JavaScript theme={null}
  import { Modulex } from "modulex-js";

  const client = new Modulex({
    apiKey: "mx_live_your_api_key",
    organizationId: "org_your_org_id",
  });

  const catalog = await client.integrations.browse();
  for (const integration of catalog.integrations) {
    console.log(integration.name, integration.display_name);
  }
  ```
</CodeGroup>

<Note>
  Browsing the catalog returns the integrations you can connect — it does not connect anything or move data. To work with credentials, see [managing credentials](/integrations/managing-credentials).
</Note>

## Don't see what you need

<CardGroup cols={2}>
  <Card title="Connect a custom MCP server" icon="server" href="/integrations/building/custom-mcp">
    Point ModuleX at an external Model Context Protocol server to use its tools alongside the built-in catalog.
  </Card>

  <Card title="Build your own integration" icon="hammer" href="/integrations/building/overview">
    Author a new integration and expose its tools to ModuleX.
  </Card>
</CardGroup>

<Note>
  Connecting a custom MCP server is a separate path from the built-in catalog above — it is not one of the 175 catalog integrations. Use it when the service you need isn't listed.
</Note>

## Next steps

<CardGroup cols={3}>
  <Card title="Integrations overview" icon="circle-info" href="/integrations/overview">
    How connectors, tools, and credentials work together.
  </Card>

  <Card title="Connect an integration" icon="link" href="/guides/connect-an-integration">
    A step-by-step walkthrough from connecting to calling a tool.
  </Card>

  <Card title="Authentication & credentials" icon="lock" href="/integrations/authentication">
    The connection methods every integration uses.
  </Card>
</CardGroup>