Using AI coding assistants with the Zendesk API to automate Zendesk workflows

This article shows you how to use an AI coding assistant, such as ChatGPT, Claude, or GitHub Copilot, to build Zendesk integrations by describing what you want in plain language.

You do not need to know every Zendesk API or AI API endpoint before you start. AI tools can help you identify likely endpoints, describe responses, and generate starter code. You should still verify those details against the Zendesk API reference as well as the AI service's API reference before using them in production.

By the end of this article, you'll know how to:

• Describe a Zendesk task in plain language so an AI coding assistant can generate working code
• Write prompts that produce reliable, safe integration scripts
• Ask AI to discover which Zendesk API and AI API endpoints and fields to use
• Validate AI-generated code before running it in production

You can apply this approach to many tasks, including editing help center articles, summarizing ticket conversations, and classifying incoming tickets.

Warning: Never send confidential, regulated, or sensitive data to external AI services unless permitted by your organization's policy.

What you can build

Using an AI coding assistant, you can generate starter scripts for workflows like the following without writing everything from scratch:

• Help center editing: Rewrite articles for clarity, fix grammar, or update tone at scale
• Ticket summarization: Help agents catch up on long ticket threads in seconds
• Ticket classification: Automatically assign categories to incoming tickets
• Response drafting: Generate first-draft replies in a consistent tone
• Content tagging: Extract keywords or metadata from articles or tickets

Each of these follows the same core approach: Describe what you want clearly, set the right constraints, and validate the result before using it.

Before you begin

You need:

• A Zendesk account with API access
• An AI provider account, such as OpenAI or Anthropic
• A development environment or a tool that can run scripts
• Basic familiarity with running a script and reading JSON

You don't need to know the exact Zendesk API. The next section shows you how to use an AI assistant to find the right endpoints for your specific task.

Using AI to discover Zendesk APIs

You don't need to browse the Zendesk API reference before writing your first integration. You can describe your goal in plain language and ask an AI coding assistant to identify the right endpoints and data structures.

For example:

"I want to fetch all public comments on a specific Zendesk ticket. What API endpoint should I use, what parameters does it accept, and what does a typical JSON response look like?"

Or:

"I want to retrieve a Zendesk help center article by id and update its body. What endpoints handle that, and what authentication method do they require?"

The AI can describe the endpoint, show you an example response structure, and generate a starter script, all from a plain-language description.

What to do with the AI's answer

Treat the AI's response as a useful starting point, not a final answer. Before running a generated script, confirm these things against the Zendesk API reference as well as the API service's API reference:

• The endpoint path exists and is current
• Field names match what the API actually returns
• The authentication method is up to date

Understanding AI limitations

AI coding assistants are trained on data up to a specific point in time. Zendesk APIs evolve, and a model may generate code that references:

• Deprecated endpoints
• Incorrect or renamed field names
• Outdated authentication methods
• Response structures that no longer match the current API

Important: Always verify AI-generated API calls against the current Zendesk API reference before running them in production. This is especially important for endpoints related to authentication, billing, or customer data.

This doesn't make AI tools less useful. It means using them requires verification steps.

Anatomy of a good prompt

The difference between a prompt that produces useful code and one that produces something you can't use usually comes down to four things:

Element	What it does	Example
Role	Tells the AI what kind of expert to behave as	"You are a Zendesk integration developer."
Task	Describes exactly what you want done	"Write a Python script that fetches a help center article and rewrites it for clarity."
Constraints	Sets limits on what to preserve, what format to return, and what to avoid	"Preserve all links, headings, and code blocks. Return only valid HTML."
Safety	Adds steps to protect data and prevent unintended changes	"Save the result locally. Do not publish to Zendesk automatically."

The more specific each element is, the more useful the output.

Common mistakes

Too vague

"Write a script to edit Zendesk articles."

This tells the AI nothing about your language, your AI provider, what "edit" means, what to preserve, or what format to return. The result will be a guess.

No output constraint

If you don't specify the output format, the model may return a mix of rewritten content and its own commentary. For automated workflows, you need the output to be machine-readable. For example, specify valid HTML only, or a single JSON object.

No safety step

A prompt that asks the AI to update Zendesk directly, without saving a local copy first, is risky. Always include a human review step before anything touches production.

A reusable template

You are [role].

Task:
[Plain-language description of what the script should do]

Instructions:
- [Input: where to get the data and which fields to use]
- [Transformation: what to do with the data]
- [Constraint: what to preserve, what format to return, what to avoid]

Safety:
- Save results locally before publishing or sending to Zendesk.
- Use environment variables for all credentials.
- Add error handling for failed API requests and unexpected responses.

Examples

The following prompts demonstrate the framework above. Each one is ready to use with an AI coding assistant.

Editing help center articles

You are a Python developer building a Zendesk help center integration.

Task:
Write a script that fetches a help center article by id and uses the OpenAI Responses API
to rewrite it for clarity, grammar, and readability.

Instructions:
- Input: Accept an article id. Fetch the article title and body using the
  Zendesk help center API. Read the Zendesk subdomain and base URL from
  environment variables.
- Transformation: Send the article body to an AI model and improve its
  clarity, grammar, and readability.
- Constraint: Preserve all links, image sources, headings, lists, and code
  blocks. Return only valid HTML for the article body. Include comments
  explaining what each part of the code does.

Safety:
- Save the edited article locally so a human can review it before publishing.
- Do not update Zendesk automatically.
- Use environment variables for Zendesk and OpenAI credentials.
- Add error handling for failed API requests and invalid responses.

Why this prompt works

Element	How it appears in the prompt
Role	Implied by the named APIs, the AI understands the domain from context
Task	Edit a help center article for clarity, grammar, and readability
Input	Fetch the article from Zendesk by id
Constraints	Preserve links, image sources, headings, lists, and code blocks; return valid HTML only
Safety	Save locally first, do not update Zendesk automatically, use environment variables

Summarizing ticket conversations

You are a Python developer building a Zendesk support integration.

Task:
Write a script that fetches all public comments on a Zendesk ticket and uses
OpenAI to produce a structured summary for a support agent.

Instructions:
- Input: Accept a Ticket id. Fetch all public comments using the Zendesk Core
  API. Consolidate the comments into a single chronological transcript. Read
  the subdomain, email, and API token from environment variables.
- Transformation: Send the transcript to an AI model with this instruction:
  "Summarize this support interaction into three bullet points: the customer's
  issue, the steps taken so far, and the next required action." If the ticket
  contains a Priority or Tier field, include it in the summary.
- Constraint: Return exactly three labeled bullet points. Redact strings that
  look like credit card numbers or passwords before sending data to the AI.
  Post the completed summary as an internal note on the Zendesk ticket.

Safety:
- Print the summary to the console and save a local copy before posting
  to Zendesk.
- Use environment variables for Zendesk and OpenAI credentials.
- Add error handling for cases where the ticket id is not found or the
  OpenAI API rate limit is reached.

Why this prompt works

Element	How it appears in the prompt
Role	Implied by the API names and the task context
Task	Summarize a ticket thread into three specific, named bullet points
Input	All public comments for a given ticket id, consolidated into a transcript
Constraints	Three bullet points, include priority or tier if present
Output	Print to console and save as an internal note on the ticket
Safety	Redact credit card numbers and passwords before sending to AI

The redaction step is especially important here. Ticket comments routinely contain sensitive customer data. Including an explicit redaction instruction means the AI coding assistant will generate code that handles this from the start, rather than leaving it as something you have to add later.

Classifying tickets

You are a Python developer building a Zendesk ticket routing integration.

Task:
Write a script that fetches a ticket from Zendesk and uses OpenAI to classify
it into a predefined category.

Instructions:
- Input: Accept a Ticket id. Fetch the ticket subject and description using
  the Zendesk Support API. Read the subdomain, email, and API token from
  environment variables.
- Transformation: Send the subject and description to an AI model and classify
  the ticket into one of these categories: Billing, Technical Issue, Account
  Access, or General Question.
- Constraint: Return only the category label — no explanation or extra text.
  Include comments explaining what each part of the code does.

Safety:
- Save the classification result locally and print it to the console before
  taking any further action.
- Use environment variables for Zendesk and OpenAI credentials.
- Add error handling for invalid ticket ids, failed API requests, and
  unexpected model responses.

Why this prompt works

Element	How it appears in the prompt
Role	Implied by the named APIs
Task	Classify a ticket into one of four predefined categories
Input	Only the subject and description, nothing extra that could skew the result
Constraints	Return only the category label, not an explanation
Safety	Save locally before taking further action, handle unexpected model output

Requesting "only the category label" matters for classification tasks. If the model returns a paragraph instead of a single label, your code can't easily parse the result. Constraining the output format makes the response directly usable in code without additional processing.

Deploying your integration

The example prompts in this article produce standalone scripts designed to run from the command line. That's intentional as it keeps the logic easy to read and easy to test on a single ticket or article before you commit to anything larger.

However, the people who will actually use these integrations are agents and admins, not developers running scripts in a terminal. A production integration typically needs a user-facing interface.

When you're ready to move beyond the command line, you can extend the Task section of your prompt to specify a delivery method. Example:

• Zendesk Apps Framework (ZAF): Build a sidebar or modal app that surfaces directly in the agent interface. This is the most natural fit for workflows an agent triggers during a support interaction, such as ticket summarization or response drafting.
• Web framework (Flask, FastAPI): Expose your script as a web service with a simple browser-based form. Useful for admin-run batch operations or workflows that don't need to live inside Zendesk.
• Desktop UI (Tkinter, PyQt): Wrap the script in a lightweight desktop application. Less common for Zendesk workflows, but workable for small teams with simple needs.

To generate a deployable version, add a line to the Task section of your prompt. For example:

"Wrap this in a minimal Flask interface with a form where the agent enters a ticket id and clicks a button to trigger the workflow. Display the result on the same page."

Or, for a Zendesk App:

"Wrap this in a Zendesk App using the Zendesk Apps Framework. The app should appear in the ticket sidebar and include a button the agent clicks to trigger the workflow. Display the result inside the app panel."

The rest of the prompt (constraints, safety steps, error handling) stays the same. You're adding one targeted instruction that tells the AI coding assistant how the script should be delivered, without changing what it does.

Validating the output

AI models don't always follow instructions perfectly. Before using any generated output, check that it:

• Follows the instructions in your prompt
• Preserves required fields such as links, headings, and code blocks
• Uses the correct output format
• Doesn't remove important information

For workflows that affect customer-facing content, a safe pattern is:

1. AI generates a draft
2. Draft is saved locally or in a staging state
3. A human reviews the draft
4. Human approves and publishes

Best practices

Start small: Test your workflow on a single low-risk item (one article, one ticket) before scaling. This makes it much easier to catch problems early.

Use the playground: Test your prompts in your AI provider's playground interface before writing any code. This lets you iterate quickly without running a full script each time.

Be explicit about preservation: List specific HTML elements (<a>, <code>, <img>, <pre>) rather than saying "preserve formatting." Vague constraints produce inconsistent results.

Always include a safety step: Ask the AI coding assistant to save results locally before publishing anything to Zendesk. This is the single most important habit for AI-assisted workflows.

Log inputs and outputs: Keep records of what was sent and what was received. This is the only reliable way to debug unexpected AI behavior after the fact.

Be token-aware: AI models charge by the token — roughly 75 words per 100 tokens. Send only the data the model needs. Use the ticket subject and description for classification, not the entire comment history.

Handle errors explicitly: Ask the AI assistant to include error handling for rate limits (HTTP 429), empty responses, and cases where the output format is unexpected. This is easy to add in the prompt and saves significant debugging time later.