Stop copying bug reports into GitHub Issues or Jira tickets by hand. Here's how Annoture's integrations eliminate that step entirely — and what that actually means for your team's speed.
There's a step that happens after almost every bug is captured that nobody talks about: someone has to copy it somewhere else.
The tester captures the bug in Annoture. Then they open GitHub or Jira, create a new issue, paste in the URL, write a description from memory, attach the screenshot manually, pick a priority, assign it — and only then does the developer see it. The bug has been captured twice.
Annoture's GitHub and Jira integrations remove that second step entirely. Here's how they work and what changes when you turn them on.
The GitHub integration
Once you connect your GitHub account in Site Settings and select a repository, every bug captured through the Annoture Chrome extension automatically creates a GitHub Issue. Not a stub — a fully formed issue with:
- The bug title and description from the capture
- The full-page screenshot embedded directly in the issue body
- Page URL, browser, OS, screen size, and viewport
- The exact CSS selector of the DOM element that was clicked
- Priority set automatically from the capture
The developer opens GitHub and everything is already there. No message from the tester saying "I filed a bug, can you take a look?" — the issue is in the repository the moment capture happens.
Screenshots that actually persist
One subtle problem with embedding screenshots in GitHub issues is URL expiry. Annoture uses Cloudflare R2 for storage, and signed URLs have a limited lifetime. We handle this by refreshing the signed URL at the moment of issue creation and embedding it directly in the issue body. GitHub's image proxy (Camo) caches the image on first load, so it persists even after the original URL expires. The screenshot in the issue stays visible indefinitely.
The Jira integration
Jira works the same way — connect your Atlassian account, pick a cloud site and project, and Annoture creates a Bug issue in that project for every capture. The difference is the format.
Jira uses Atlassian Document Format (ADF) for issue descriptions, not Markdown. We build the description natively in ADF so it renders properly inside Jira — the screenshot appears as an inline image, and the browser/OS/viewport metadata is formatted as a structured table rather than a wall of text.
The result looks like a human wrote a thorough Jira ticket, not like a tool pasted plain text into a description field.
Token refresh handled automatically
Atlassian access tokens expire after approximately one hour. Most integrations break quietly when this happens — the next capture just silently fails to create a Jira issue. Annoture stores the refresh token securely and refreshes the access token automatically before each issue creation. Your integration keeps working overnight, across weekends, and during long testing sessions without any manual re-authorisation.
Why both, not just one
The two integrations aren't alternatives — teams often use them together. Developers might live in GitHub while PMs and project managers track work in Jira. With both integrations active, a single capture creates an issue in both places simultaneously. Neither team has to wait for the other to manually forward information.
What stays on the Annoture board
Enabling an integration doesn't remove reports from Annoture. Everything still appears on your Kanban board — the GitHub Issue number and Jira ticket key are shown as badges on each report card. Clicking either badge opens the corresponding issue directly. The Annoture board becomes the central view that links out to wherever the work is actually being done.
Setting it up
Both integrations are in Site Settings — accessible from the Settings icon next to your site's Kanban board. The GitHub setup takes about 30 seconds: authorise, pick a repo, save. Jira takes slightly longer because you pick a cloud site first, then a project. After that, the integration runs silently in the background. There's nothing to configure per-report.
GitHub integration is available on all plans, including free. Jira integration requires an active plan.
The integrations coming next
GitHub and Jira are live now. Slack, Linear, and Figma integrations are next — Slack for instant channel notifications when a bug is captured, Linear for teams that use it as their primary issue tracker, and Figma for linking bug reports directly to the design frames they affect. If there's an integration your team needs that isn't on the roadmap, the fastest way to get it prioritised is to request it.
The pattern across all of them is the same: capture once in Annoture, and the right people see it in the tool they already use — without anyone copying anything.