Integrating OpenClaw IT Helpdesk Agent with Jira Service Management and ServiceNow

1. Introduction

Modern IT support teams demand a single pane of glass that can ingest alerts from monitoring tools, route them to the right helpdesk system, and keep stakeholders informed without manual effort. OpenClaw—UBOS’s full‑stack, AI‑powered helpdesk agent—delivers exactly that. By bridging UBOS homepage capabilities with the industry‑standard platforms Jira Service Management and ServiceNow, developers can automate ticket lifecycles, enforce SLAs, and free up engineers for higher‑value work.

This guide walks you through every step—from cloning the OpenClaw template to deploying a production‑ready instance on UBOS’s managed hosting.

2. Prerequisites

• OpenClaw full‑stack template – available in the UBOS templates for quick start marketplace.
• Jira Service Management credentials – an API token generated from your Atlassian account.
• ServiceNow credentials – client ID, client secret, and instance URL for OAuth 2.0.
• Node.js ≥ 18, Git, and a Web app editor on UBOS for local tweaks.

3. Setting Up the OpenClaw Full‑Stack Template

3.1 Clone the repository

git clone https://github.com/ubos-tech/openclaw-fullstack.git
cd openclaw-fullstack
npm install

3.2 Environment configuration

Create a .env file at the project root and populate it with the placeholders below. Each variable is scoped to a single integration, keeping the configuration mutually exclusive, collectively exhaustive (MECE) for maintainability.

# OpenClaw core
PORT=3000
LOG_LEVEL=info

# Jira Service Management
JIRA_BASE_URL=https://your-domain.atlassian.net
JIRA_EMAIL=you@example.com
JIRA_API_TOKEN=your_jira_api_token

# ServiceNow
SNOW_INSTANCE=https://your-instance.service-now.com
SNOW_CLIENT_ID=your_client_id
SNOW_CLIENT_SECRET=your_client_secret
SNOW_OAUTH_TOKEN_URL=https://your-instance.service-now.com/oauth_token.do

After saving, start the development server:

npm run dev

Visit http://localhost:3000 to verify the UI loads. For a visual overview of the platform, explore the UBOS platform overview.

4. Connecting to Jira Service Management API

4.1 Authentication (API token)

Jira uses Basic Auth with an email address and an API token. The OpenClaw jiraClient.js module encapsulates this logic:

const axios = require('axios');
const auth = Buffer.from(`${process.env.JIRA_EMAIL}:${process.env.JIRA_API_TOKEN}`).toString('base64');

const jira = axios.create({
  baseURL: process.env.JIRA_BASE_URL,
  headers: { Authorization: `Basic ${auth}` }
});

module.exports = jira;

4.2 Creating tickets via REST

OpenClaw receives an alert payload, maps it to Jira fields, and posts to /rest/api/3/issue:

async function createJiraTicket(alert) {
  const payload = {
    fields: {
      project: { key: "IT" },
      summary: `[OpenClaw] ${alert.title}`,
      description: alert.description,
      issuetype: { name: "Incident" },
      priority: { name: alert.severity }
    }
  };
  const response = await jira.post('/rest/api/3/issue', payload);
  return response.data.key;
}

4.3 Updating tickets

When the alert status changes, OpenClaw patches the issue:

async function updateJiraTicket(issueKey, status) {
  const transitionId = status === 'resolved' ? '31' : '21'; // example IDs
  await jira.post(`/rest/api/3/issue/${issueKey}/transitions`, {
    transition: { id: transitionId }
  });
}

5. Connecting to ServiceNow API

5.1 Authentication (OAuth/client credentials)

ServiceNow requires an OAuth token. The helper below fetches and caches the token for the session:

const qs = require('querystring');
const axios = require('axios');

let cachedToken = null;

async function getSnowToken() {
  if (cachedToken && cachedToken.expires_at > Date.now()) return cachedToken.access_token;

  const response = await axios.post(process.env.SNOW_OAUTH_TOKEN_URL, qs.stringify({
    grant_type: 'client_credentials',
    client_id: process.env.SNOW_CLIENT_ID,
    client_secret: process.env.SNOW_CLIENT_SECRET
  }), { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });

  cachedToken = {
    access_token: response.data.access_token,
    expires_at: Date.now() + response.data.expires_in * 1000
  };
  return cachedToken.access_token;
}

5.2 Creating incidents via Table API

ServiceNow’s Table API lets you POST to /api/now/table/incident. OpenClaw builds the incident payload from the same alert object used for Jira:

async function createSnowIncident(alert) {
  const token = await getSnowToken();
  const response = await axios.post(
    `${process.env.SNOW_INSTANCE}/api/now/table/incident`,
    {
      short_description: `[OpenClaw] ${alert.title}`,
      description: alert.description,
      urgency: alert.severity === 'Critical' ? '1' : '2',
      impact: '1',
      caller_id: 'admin'
    },
    { headers: { Authorization: `Bearer ${token}` } }
  );
  return response.data.result.number;
}

5.3 Updating incidents

When the alert resolves, update the incident state:

async function updateSnowIncident(incidentNumber, state) {
  const token = await getSnowToken();
  await axios.patch(
    `${process.env.SNOW_INSTANCE}/api/now/table/incident?sysparm_query=number=${incidentNumber}`,
    { state },
    { headers: { Authorization: `Bearer ${token}` } }
  );
}

6. Automating Ticket Creation and Updates

6.1 Event‑driven workflow in OpenClaw

OpenClaw’s Workflow automation studio lets you define a JSON‑based rule set that triggers on incoming alerts:

{
  "rules": [
    {
      "when": "alert.created",
      "then": [
        "createJiraTicket",
        "createSnowIncident"
      ]
    },
    {
      "when": "alert.resolved",
      "then": [
        "updateJiraTicket",
        "updateSnowIncident"
      ]
    }
  ]
}

6.2 Mapping fields between OpenClaw, Jira, and ServiceNow

Maintain a single source of truth for field mapping to avoid drift:

6.3 Sample code snippet – unified handler

async function handleAlert(alert) {
  const jiraKey = await createJiraTicket(alert);
  const snowNumber = await createSnowIncident(alert);
  // Store correlation IDs for later updates
  await db.save({ alertId: alert.id, jiraKey, snowNumber });
}

async function resolveAlert(alertId) {
  const record = await db.find({ alertId });
  await updateJiraTicket(record.jiraKey, 'resolved');
  await updateSnowIncident(record.snowNumber, '6'); // 6 = Resolved
}

7. Testing the Integration

7.1 Unit tests

Use jest to mock external APIs. Example for Jira ticket creation:

test('createJiraTicket sends correct payload', async () => {
  const mockPost = jest.spyOn(jira, 'post').mockResolvedValue({ data: { key: 'IT-123' } });
  const alert = { title: 'CPU Spike', description: 'CPU > 90%', severity: 'High' };
  const key = await createJiraTicket(alert);
  expect(key).toBe('IT-123');
  expect(mockPost).toHaveBeenCalledWith('/rest/api/3/issue', expect.objectContaining({
    fields: expect.objectContaining({ summary: '[OpenClaw] CPU Spike' })
  }));
});

7.2 End‑to‑end scenario

Deploy the app locally, fire a test webhook from your monitoring tool, and verify that:

1. A Jira incident appears in the IT project.
2. A ServiceNow incident is listed with the same short description.
3. When you close the alert, both tickets transition to “Resolved”.

For a visual checklist, see the UBOS portfolio examples where similar integrations are showcased.

8. Deployment Options

Once you’ve validated locally, you have two primary paths:

• Self‑hosted on your own Kubernetes cluster – ideal for enterprises with strict compliance requirements.
• UBOS managed hosting – a production‑ready, one‑click deployment that includes auto‑scaling, SSL, and built‑in monitoring. Deploy OpenClaw with a single command via the production‑ready hosting page.

UBOS’s Enterprise AI platform by UBOS also offers advanced logging, role‑based access control, and AI‑driven analytics that can further enrich your helpdesk data.

Pricing details are transparent; review the UBOS pricing plans to choose a tier that matches your usage.

9. Conclusion

By leveraging OpenClaw’s modular architecture, developers can seamlessly synchronize incidents across Jira Service Management and ServiceNow, ensuring that every alert becomes a tracked, auditable ticket. The combination of UBOS’s low‑code Web app editor, Workflow automation studio, and robust API clients reduces integration effort from weeks to hours.

Ready to accelerate your IT support workflow? Explore the UBOS templates for quick start, or dive into a ready‑made AI Chatbot template that demonstrates similar event‑driven patterns.

For further reading on AI‑enhanced helpdesks, check out the AI marketing agents page, which outlines how generative AI can automate repetitive tasks across the organization.

Happy coding, and may your tickets always resolve before the SLA expires!

For background on the original announcement, see the news article that first introduced OpenClaw’s integration capabilities.