DEV Community: Abdul Qadir

AI-Powered Test Generation: Jira to Xray with CrewAI: Part 2 — Agents, Tasks, and Xray Integration

Abdul Qadir — Wed, 18 Mar 2026 01:42:32 +0000

Discover how CrewAI agents can automatically convert Jira requirements into Xray test cases. Includes full setup instructions, project layout, and a ready-to-run GitHub example.

Section 1 — Defining the CrewAI Agents

With the project structure in place, the next step is understanding the agents that drive the workflow.

In CrewAI, agents are assigned clear responsibilities. Rather than relying on a single general-purpose agent, this project uses two specialized agents: one to generate test cases and another to review and improve them.

The actual agent definitions live in config/agents.yaml:

test_case_writer:
  role: QA Test Case Writer
  goal: Write comprehensive functional test cases from Jira stories
  backstory: >
    You are a senior QA engineer.
    You write clear, structured test cases
    including positive, negative, and edge scenarios.
  verbose: true
  llm: openai/gpt-5-nano

test_case_reviewer:
  role: QA Test Case Reviewer
  goal: Review and improve test cases for quality and coverage
  backstory: >
    You are a QA lead.
    You ensure test cases fully cover acceptance criteria,
    are clear, consistent, and complete.
  verbose: true
  llm: openai/gpt-5.4

What these agents do

The QA Test Case Writer reads the Jira story and creates an initial set of functional test cases.
The QA Test Case Reviewer checks those test cases for clarity, completeness, and overall coverage before they are sent to Xray.

This two-agent approach mirrors a real QA workflow. One agent focuses on drafting the tests, while the second acts as a quality gate to refine the output. In many cases, it also makes sense to use different LLMs for these roles, such as one model for fast generation and another for stronger review quality.

Why this configuration matters

Each agent definition includes a few important pieces:

role defines the responsibility of the agent in the workflow.
goal tells the agent what outcome it should aim for.
backstory gives behavioral context that helps shape the style and quality of its output.
llm specifies which model powers the agent.
verbose: true makes execution easier to inspect during development.

One of CrewAI’s strengths is that this behavior can be adjusted in YAML without changing core application logic. That makes the system easier to tune as your prompts, test quality standards, or workflow evolve.

In the next section, we’ll look at how these agents are assigned work through tasks.yaml, and how the overall process moves from Jira requirements to Xray-ready test cases.

Section 2 — Defining the Tasks

Once the agents are defined, the next step is assigning work to them. In CrewAI, this is done through config/tasks.yaml.

This file describes what each agent should do, what input it receives, what output it should produce, and where that output should be saved. In this project, the workflow is split into two tasks: one for writing test cases and one for reviewing and publishing them.

The actual task definitions look like this:

write_test_cases:
  description: >
    INPUT:
    - story: Jira user story text

    You are provided with a Jira user story.

    Your task is to write comprehensive functional test cases based on the story.

    Requirements:
    - Cover positive, negative, and edge cases
    - Align all test cases with the acceptance criteria
    - Use clear, unambiguous language

    Each test case must include:
    - Test Case ID
    - Title
    - Preconditions
    - Test Steps
    - Expected Result

    Jira User Story:
    {story}

    Output the test cases in Markdown format.
    Save the output to output/test_cases_v1.md.
  expected_output: >
    A Markdown file containing clear, well-structured functional test cases
    derived from the Jira user story.
  agent: test_case_writer
  output_file: output/test_cases_v1.md

review_test_cases:
  description: >
    INPUTS:
    - story: Jira user story text

    You are provided with:
    - The original Jira user story
    - A set of test cases written in output/test_cases_v1.md

    Jira User Story:
    {story}

    Review the existing test cases and improve them by:
    - Ensuring full coverage of acceptance criteria
    - Identifying and adding missing scenarios
    - Improving clarity and consistency
    - Removing redundancy or ambiguity

    Do NOT remove valid test cases unless necessary.
    You may refactor, merge, or expand them where appropriate.

    Output the improved test cases in Markdown format.
    Save the output to output/test_cases_v2_reviewed.md.

    After generating the final improved test cases,
    use the "XrayCreateTestTool" to create a Manual Test
    in Xray for each finalized test case.

    Pass:
    - summary = Test Case Title
    - description = Full test case content
    - project_key = "SCRUM"
  expected_output: >
    A reviewed and improved Markdown file containing high-quality,
    acceptance-criteria-aligned test cases.
  agent: test_case_reviewer
  output_file: output/test_cases_v2_reviewed.md

What these tasks do

The first task, write_test_cases, is assigned to the test_case_writer agent. Its job is to read the Jira story and generate the first version of the test cases. The output is saved to output/test_cases_v1.md.

The second task, review_test_cases, is assigned to the test_case_reviewer agent. This task takes the original Jira story along with the first draft of the test cases, improves the content, and saves the final reviewed version to output/test_cases_v2_reviewed.md.

Why this task design works well

This setup creates a simple but effective two-stage workflow:

the first task focuses on generation
the second task focuses on refinement and delivery

That separation improves the final quality of the tests while keeping each agent’s responsibility clear.

Another important detail is that the review task does more than just edit Markdown output. It also instructs the reviewer agent to call the XrayCreateTestTool, which creates a Manual Test issue in Xray for each finalized test case. This is the step that moves the workflow from AI-generated content to actual test management inside Jira.

Key takeaway

The tasks.yaml file acts as the operational blueprint of the system. It tells CrewAI what should happen, in what sequence, and what each stage should produce.

In the next section, we’ll look at how these agents and tasks are wired together in crew.py to create the full CrewAI workflow.

Section 3 — Wiring the Workflow in crew.py

After defining the agents and tasks, the next step is connecting them into a working workflow. In this project, that orchestration happens in crew.py.

This file is where the CrewAI application is assembled. It maps the YAML configuration into Python objects, attaches tools to the right agent, and defines how the tasks should run.

The core implementation looks like this:

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from testcrew_ai.tools.xray_tool import XrayCreateTestTool
from typing import Any

@CrewBase
class TestCrewAI:
    """
    Crew class for manual test case writing and reviewing.
    """
    agents_config: str = 'config/agents.yaml'
    tasks_config: str = 'config/tasks.yaml'

    @agent
    def test_case_writer(self) -> Agent:
        """Agent responsible for writing test cases."""
        return Agent(
            config=self.agents_config['test_case_writer'],
            verbose=True
        )

    @agent
    def test_case_reviewer(self) -> Agent:
        """Agent responsible for reviewing test cases, with Xray tool."""
        return Agent(
            config=self.agents_config['test_case_reviewer'],
            verbose=True,
            tools=[XrayCreateTestTool()]
        )

    @task
    def write_test_cases(self) -> Task:
        """Task for writing test cases."""
        return Task(
            config=self.tasks_config['write_test_cases'],
        )

    @task
    def review_test_cases(self) -> Task:
        """Task for reviewing test cases."""
        return Task(
            config=self.tasks_config['review_test_cases'],
        )

    @crew
    def crew(self) -> Crew:
        """Creates the manual testing crew."""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True,
        )

What crew.py does

This file serves as the bridge between configuration and execution.

It loads agent definitions from config/agents.yaml
It loads task definitions from config/tasks.yaml
It creates Python Agent and Task objects using CrewAI decorators
It attaches the XrayCreateTestTool to the reviewer agent
It runs the workflow using a sequential process

Why the reviewer gets the Xray tool

One important design choice in this file is that the XrayCreateTestTool is attached only to the test_case_reviewer agent.

That means the writer agent is responsible only for generating draft test cases, while the reviewer agent handles the final refinement and the publishing step into Xray. This is a clean separation of responsibilities and helps keep the workflow easier to reason about.

Why use Process.sequential

The crew is configured with Process.sequential, which means the tasks run in order rather than in parallel.

That makes sense for this use case because the second task depends on the output of the first one:

first, the writer creates the initial test cases
then, the reviewer improves them
finally, the reviewer uses the Xray tool to create Manual Test issues

A sequential flow is the simplest and safest orchestration model for this kind of staged QA pipeline.

Why this file matters

If agents.yaml defines who the agents are, and tasks.yaml defines what they do, then crew.py defines how everything comes together into one executable system.

It is the file that turns configuration into a working CrewAI pipeline.

In the next section, we’ll look at main.py, where the Jira issue is fetched, prepared as input, and passed into the crew for execution.

Section 4 — Running the Workflow from main.py

With the agents, tasks, and crew now defined, the final step is to run the workflow with a real Jira issue. In this project, that logic lives in main.py.

This file acts as the entry point of the application. It loads environment variables, fetches a Jira issue, extracts the story content into a format suitable for the agents, and then starts the CrewAI workflow.

The key parts of main.py are shown below:

#!/usr/bin/env python
import os
import warnings
import requests
from requests.auth import HTTPBasicAuth
from dotenv import load_dotenv
from typing import Dict
from testcrew_ai.crew import TestCrewAI

warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")

# Load .env variables
load_dotenv()

JIRA_BASE_URL = os.getenv("JIRA_BASE_URL")
JIRA_EMAIL = os.getenv("JIRA_EMAIL")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")

def get_jira_issue(issue_key: str) -> Dict:
    """
    Fetch a Jira issue by key.
    """
    url = f"{JIRA_BASE_URL}/rest/api/3/issue/{issue_key}"
    response = requests.get(
        url,
        auth=HTTPBasicAuth(JIRA_EMAIL, JIRA_API_TOKEN),
        headers={"Accept": "application/json"}
    )
    response.raise_for_status()
    return response.json()

def extract_story_for_ai(issue: Dict) -> str:
    """
    Extracts a formatted story from a Jira issue for AI processing.
    """
    fields = issue["fields"]
    description_text = "No description provided"
    description = fields.get("description")
    if description and "content" in description:
        lines = []
        for block in description["content"]:
            if "content" in block:
                for item in block["content"]:
                    if item.get("type") == "text":
                        lines.append(item["text"])
        description_text = "\n".join(lines)
    return f"""
Title:
{fields.get("summary", "No title")}

Description:
{description_text}

Issue Type:
{fields["issuetype"]["name"]}

Priority:
{fields["priority"]["name"] if fields.get("priority") else "Not set"}
""".strip()

def run(issue_key: str = None) -> None:
    """
    Run the research crew for a given Jira issue key.
    """
    if issue_key is None:
        issue_key = os.getenv("JIRA_ISSUE_KEY", "SCRUM-1")
    issue = get_jira_issue(issue_key)
    story_text = extract_story_for_ai(issue)
    inputs = {'story': story_text}
    result = TestCrewAI().crew().kickoff(inputs=inputs)
    print(result)

if __name__ == " __main__":
    run()

What main.py does

This file is responsible for preparing the real-world input that the agents will use.

It loads Jira credentials from .env
It fetches a Jira issue using the Jira REST API
It extracts useful fields such as title, description, issue type, and priority
It converts that data into a structured text prompt
It passes that prompt into the CrewAI workflow as the story input

Why the story extraction step matters

The agents do not work directly with raw Jira JSON. Instead, extract_story_for_ai() transforms the issue into a cleaner, readable text format.

That is important because LLMs perform much better when given structured natural language rather than deeply nested API responses. By extracting only the fields that matter, the project gives the agents a clearer understanding of the requirement they need to convert into test cases.

How the execution flow works

At runtime, the flow is simple:

a Jira issue key is provided, either directly or through the .env file
the issue is fetched from Jira
the story is formatted for AI processing
the crew is kicked off with that story as input
the tasks run in sequence until the final reviewed test cases are created and sent to Xray

This makes main.py the handoff point between Jira data and the CrewAI pipeline.

In the next section, we’ll look at the custom xray_tool.py implementation, which is responsible for creating Manual Test issues in Xray from the final reviewed output.

Section 5 — Creating Manual Tests in Xray with xray_tool.py

The final piece of the workflow is the custom tool that sends the reviewed test cases into Xray. This logic lives in tools/xray_tool.py.

While the agents and tasks handle the AI-driven parts of the pipeline, this tool handles the external integration. Its job is to authenticate with Xray Cloud and create Manual Test issues in the target Jira project.

Here is the implementation used in this project:

import os
import requests
from dotenv import load_dotenv
from crewai.tools import BaseTool
from typing import Any, Dict

def load_xray_env() -> Dict[str, str]:
    """
    Loads and returns Xray credentials from environment variables.
    Raises an exception if required variables are missing.
    """
    load_dotenv()
    client_id = os.getenv("XRAY_CLIENT_ID")
    client_secret = os.getenv("XRAY_CLIENT_SECRET")
    if not client_id or not client_secret:
        raise EnvironmentError("XRAY_CLIENT_ID and XRAY_CLIENT_SECRET must be set in environment.")
    return {"client_id": client_id, "client_secret": client_secret}

def get_xray_token() -> str:
    """
    Authenticates with Xray and returns a bearer token.
    """
    creds = load_xray_env()
    response = requests.post(
        "https://xray.cloud.getxray.app/api/v2/authenticate",
        json={
            "client_id": creds["client_id"],
            "client_secret": creds["client_secret"]
        }
    )
    response.raise_for_status()
    return response.text.strip('"')

class XrayCreateTestTool(BaseTool):
    name: str = "Create Xray Test"
    description: str = "Creates a Manual Test in Xray Jira project"

    def _run(self, summary: str, description: str, project_key: str = "SCRUM") -> Any:
        """
        Creates a manual test in the specified Xray Jira project.
        """
        token = get_xray_token()
        payload = [
            {
                "xray_testtype": "Manual",
                "fields": {
                    "project": {"key": project_key},
                    "summary": summary,
                    "description": description,
                    "issuetype": {"name": "Test"},
                }
            }
        ]
        response = requests.post(
            "https://xray.cloud.getxray.app/api/v2/import/test/bulk",
            headers={
                "Authorization": f"Bearer {token}",
                "Content-Type": "application/json"
            },
            json=payload
        )
        response.raise_for_status()
        return response.json()

How the tool works

This tool performs two main steps:

It authenticates with Xray Cloud using XRAY_CLIENT_ID and XRAY_CLIENT_SECRET
It sends a request to the Xray bulk test import API to create a Manual Test issue

The authentication step returns a bearer token, which is then included in the request headers for the test creation call.

Why this tool matters

This is the point where the workflow moves beyond text generation and becomes actionable.

Up to this stage, the agents are producing and refining Markdown test cases. But with XrayCreateTestTool, the final output is pushed directly into Xray as real Jira Test issues. That makes the system much more useful in practice, because the generated tests are no longer just suggestions, they become part of the team’s test management workflow.

How it connects to the review task

Earlier, in tasks.yaml, the reviewer task instructed the agent to call XrayCreateTestTool after producing the final improved test cases.

That means the reviewer agent is responsible for:

validating the quality of the final test cases
selecting the finalized content
sending each approved test case to Xray

This is a nice design because it keeps test publication tied to the quality-control stage rather than the initial draft stage.

Running the full Jira-to-Xray workflow

After setting up the project and configuring your credentials, run:

crewai run

This will execute the CrewAI pipeline end to end:

fetch the Jira story
generate the first draft of test cases
review and improve the test cases
create Manual Test issues in Xray

The screenshot below shows the project running through the CrewAI pipeline.

Wrapping up

At this point, the full workflow is in place:

Jira provides the source requirement
the writer agent generates initial test cases
the reviewer agent improves them
the custom Xray tool creates Manual Test issues in Jira

Together, these pieces form an end-to-end pipeline that turns Jira stories into structured, reviewable, and publishable Xray tests using CrewAI.

Read part 1 — https://dev.to/abdul_qadir/ai-powered-test-generation-jira-to-xray-with-crewai-part-1-setup-and-project-overview-p0a

AI-Powered Test Generation: Jira to Xray with CrewAI — Part 1: Setup and Project Overview

Abdul Qadir — Wed, 18 Mar 2026 01:41:02 +0000

Discover how CrewAI agents can automatically convert Jira requirements into Xray test cases. Includes full setup instructions, project layout, and a ready-to-run GitHub example.

Prerequisites

Before starting this tutorial, make sure you have completed the following setup steps. Each guide walks you through the process from scratch.

These credentials and accounts are required for the CrewAI agents to interact with Jira and Xray.

Required Accounts & API Access

OpenAI API Access

How to Create an OpenAI Account, Generate an API Key, and Add Credits | by Abdul Qadir | Mar, 2026 | Medium

Jira Test Account

How to Set Up a Jira Test Account and Generate an API Key | by Abdul Qadir | Mar, 2026 | Medium

Xray for Jira Setup

How to Set Up Xray for Jira and Generate Client ID and Client Secret | by Abdul Qadir | Mar, 2026 | Medium

Why We Are Using CrewAI?

There are many agent frameworks available today, but CrewAI is a great choice for this project, especially if you’re new to building AI agents.

Key Advantages

Beginner-friendly — simple concepts and minimal boilerplate

Role-based agents — define agents with clear goals (e.g., writer, reviewer)

YAML configuration — behavior can be defined without heavy coding

Fast to prototype — go from idea to working multi-agent system quickly

Lightweight — easier to understand than more complex orchestration frameworks

Active community — growing ecosystem and documentation

In short, CrewAI lets you focus on what the agents should do, not on building infrastructure.

For a project like converting Jira stories into Xray tests, this simplicity makes development faster and much easier for newcomers

Section 1 — Clone the Repository

Start by cloning the public project repository to your machine. This repo contains the full CrewAI project, configuration files, and example code used in this tutorial.

1. Install Git (if not already installed)

Check if Git is installed:

Windows / macOS

git --version

If you see a version number, you’re good to go.

2. Clone the repository

qadir-dev-hub/ai-xray-test-generator

Windows (PowerShell)

git clone qadir-dev-hub/ai-xray-test-generator
cd testcrew_ai

macOS / Linux (Terminal)

git clone qadir-dev-hub/ai-xray-test-generator
cd testcrew_ai

3. Create your environment file

Copy the example environment file:

Windows

copy .env.example .env

macOS / Linux

cp .env.example .env

Open .env and fill in your credentials (Xray, Jira, etc.).

Section 2 — Install uv and Project Dependencies

This project uses uv to manage Python environments and dependencies.

uv automatically creates a virtual environment and installs everything defined in pyproject.toml.

Install uv

Windows (PowerShell)

Run this command:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

This will:

Install uv for your user

Add it to your PATH

Require no admin privileges

macOS / Linux

Run:

curl -LsSf https://astral.sh/uv/install.sh | sh

Verify installation

Close and reopen your terminal, then run:

uv --version

If a version number appears, installation succeeded

If uv is not recognized, restart your terminal or log out and back in so the PATH update takes effect.

Install project dependencies

Make sure you are in the project root (the folder containing pyproject.toml), then run:

uv sync

This command will:

Create a .venv virtual environment

Install CrewAI and all required packages

Generate a uv.lock file for reproducible installs

Quick sanity check

If everything installed correctly, you can test Python execution inside the environment:

uv run python --version

You should see Python 3.10–3.13 (as defined in the project requirements).

Architecture Diagram

This diagram shows how a Jira user story is transformed into Xray manual tests using AI agents built with CrewAI.

A user story from Jira serves as the input.
CrewAI orchestrates the workflow between agents.
The Test Case Writer Agent generates initial test cases.
The Test Case Reviewer Agent refines and finalizes them.
A custom tool calls the Xray API to create tests.
Xray saves the manual Test issues back in Jira.

In short, the pipeline automates the flow from requirements → AI-generated test cases → ready-to-use Xray tests , significantly reducing manual effort.

Section 3 — Project Structure Overview

Now that the project is installed, let’s take a quick look at how the repository is organized.

Understanding the project structure will make it much easier to follow how CrewAI agents, tasks, and tools work together to generate Xray test cases from Jira requirements.

A simplified view of the repository looks like this:

testcrew_ai/
├── src/
│ └── testcrew_ai/
│ ├── config/
│ │ ├── agents.yaml
│ │ └── tasks.yaml
│ ├── tools/
│ │ └── xray_tool.py
│ ├── crew.py
│ └── main.py
├── .env
├── pyproject.toml
└── README.md

What each part does

config/agents.yaml Defines the AI agents used in the workflow, including their roles, goals, and behavior.
config/tasks.yaml Describes the tasks assigned to each agent, such as generating and reviewing test cases.
tools/xray_tool.py Contains the custom tool responsible for connecting to the Xray API and creating manual test cases in Jira.
crew.py Brings the agents, tasks, and tools together into a CrewAI workflow.
main.py Serves as the entry point for running the project.
.env Stores the API keys and credentials required for OpenAI, Jira, and Xray.
pyproject.toml Manages project metadata and dependencies.

Why this structure works well

This layout keeps the project clean and easy to extend:

Configuration is separated from code
Agents and tasks are easy to update without rewriting logic
External integrations are isolated inside reusable tools
The execution flow stays simple and readable

This separation is one of the reasons CrewAI is a good fit for projects like this. You can clearly see where the agent behavior lives, where the business logic lives, and where external systems like Xray are connected.

In the next section, we’ll look at how the agents are defined and how each one contributes to the test generation workflow and how these agents are assigned work through tasks.yaml, and how the overall process moves from Jira requirements to Xray-ready test cases.

Read part 2 here — https://dev.to/abdul_qadir/ai-powered-test-generation-jira-to-xray-with-crewai-part-2-agents-tasks-and-xray-integration-3jid

Getting Started with Xray for Jira: Setup, Test Configuration, and API Keys

Abdul Qadir — Sun, 15 Mar 2026 16:10:55 +0000

If you're building test automation, integrating CI/CD pipelines, or working with AI-driven QA workflows, setting up Xray correctly is the first step.

This guide walks you through the full setup—from installation to generating API credentials you can use in automation.

What Is Xray?

Xray Test Management is a powerful test management app that integrates directly with Jira. It allows teams to manage manual and automated tests, track execution results, and connect testing to requirements and defects.

Step 1 — Install Xray in Jira

Log in to your Jira Cloud instance
Click the Settings icon (gear)
Select Apps or Manage apps
Click Find new apps
Search for Xray Test Management
Click Try it free or Install

After installation, Xray will be added to your Jira environment.

Note: You must be a Jira administrator to install apps.

Step 2 — Create a Test Issue Type in Jira

Xray stores test cases as a special issue type called Test. If your Jira instance does not already have this issue type, you must create it.

Go to Space Settings
Click Add work type
Name it Test
Select an icon and click Create

Step 3 — Link the Jira Test Issue Type to Xray

After creating the Test issue type, ensure Xray recognizes it.

Open Jira Settings
Navigate to Apps
Open Xray settings
Locate Issue Type Mapping or Test Issue Configuration
Confirm that the Test issue type is mapped as an Xray Test

This allows Xray to treat those issues as test cases.

Step 4 — Generate Client ID and Client Secret

To use Xray’s REST API (for automation tools or scripts), you need authentication credentials.

In Xray settings, find the API Keys or API Access section
Click Create API Key or Generate Credentials
Copy the Client ID
Copy the Client Secret
Store both values securely

Important: The Client Secret is sensitive and may not be shown again.

Step 5 — Use the Credentials (API Example)

Once you have your credentials, you can authenticate with Xray and start using its APIs.

Here’s a simple example to get an authentication token:


bash
curl -X POST "https://xray.cloud.getxray.app/api/v2/authenticate" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET"
  }'

Jira API Token Guide: Create a Test Account and Generate API Keys (2026)

Abdul Qadir — Sun, 15 Mar 2026 02:39:27 +0000

If you're building integrations, test automation, or AI-driven workflows with Jira, you'll need an API token to authenticate your requests.

This guide shows how to quickly create a Jira test account and generate an API token you can use in scripts, CI/CD pipelines, or automation tools.

Step 1 — Create a Jira Account

Go to https://www.atlassian.com/software/jira
Click Get it free
Sign up using your email, Google account, or Microsoft account
Follow the prompts to create your Jira site (e.g. yourname.atlassian.net)
Once complete, you’ll have access to a free Jira Cloud instance

This environment is perfect for testing integrations and automation safely.

Step 2 — Generate an API Token

An API token allows scripts and tools to authenticate securely without using your password.

Go to: https://id.atlassian.com/manage-profile/security/api-tokens
Click Create API token
Enter a label (e.g. Jira Automation)
Click Create
Copy the token and store it securely

Important: You won’t be able to view the token again after closing the dialog.

Step 3 — Use the API Token (Example)

Most tools authenticate to Jira Cloud using:

Username → your Atlassian email
Password → your API token

Here’s a simple example using curl:


bash
curl -u your-email@example.com:YOUR_API_TOKEN \
  -X GET \
  -H "Accept: application/json" \
  https://your-domain.atlassian.net/rest/api/3/project

OpenAI API Quick Start (2026): Account, API Key, and Billing Setup

Abdul Qadir — Fri, 13 Mar 2026 21:24:46 +0000

If you want to start experimenting with OpenAI APIs, here’s a quick guide to get you set up. This covers account creation, generating an API key, and adding a small prepaid balance, perfect if you just want to test things out.

If you're building apps, automations, or AI agents, this is the fastest way to get your OpenAI API access ready.

1. Create your OpenAI account

Go to https://auth.openai.com/ and click Sign up.

You can create an account using your email address, or sign in with Google or Microsoft. After entering your details, you’ll need to verify your email and complete a few basic prompts.

2. Generate an API key

Once your account is ready, go to https://platform.openai.com/ and sign in.

Open the Settings menu and navigate to API Keys. Click Create new secret key , then copy the key immediately. You won’t be able to see it again after you close the dialog.

Treat this key like a password. Anyone with access to it can use your credits.

3. Add credits to your account

To use the API, you need a prepaid balance.

Go to the billing section at:

https://platform.openai.com/settings/organization/billing/overview

Click Add credit , enter your payment details, and choose an amount. The minimum top‑up is typically $5.

After confirming, your balance will be available for API usage. You may see a temporary authorization charge on your card, which is normal and usually reversed automatically.

How long does $5 last?

For simple testing, short prompts and occasional requests , a $5 credit can last for months. It depends entirely on how often you use the API and which models you call.

If you’re just learning, building small demos, or experimenting locally, $5 is usually more than enough to get started.

Monitor your usage

You can monitor your API usage and track how quickly your credits are being spent here:

https://platform.openai.com/settings/organization/usage

This is especially helpful if you’re testing with limited credits or want to keep your usage under control.

Basic security tips

Do not share your API key publicly or commit it to source control.

Use environment variables or a secure secrets manager instead of hardcoding the key in your code.

If you think your key has been exposed, delete it and generate a new one immediately.

Final thoughts

That’s all you need to start using OpenAI’s APIs. The entire process takes only a few minutes, and a small prepaid balance is enough for most beginner experiments.

Once you’re set up, you can begin building apps, automations, or integrations powered by AI.