Integrations
SetGet integrates with the tools your team already relies on. Instead of forcing everyone into a single application, SetGet acts as the central hub for project management while syncing with code repositories, communication platforms, error trackers, and diagramming tools. This page provides an overview of every available integration and guidance on choosing the right ones for your workflow.
Why integrate?
Integrations solve three common problems:
- Context switching -- developers, designers, and managers move between tools dozens of times per day. Integrations reduce the need to copy-paste information between systems.
- Data silos -- when work item status lives in one tool and code changes live in another, nobody has the full picture. Syncing state across tools gives everyone a single source of truth.
- Manual bookkeeping -- updating a work item every time a pull request is merged or a bug is reported in production is tedious and error-prone. Integrations automate those updates.
Available integrations
| Integration | Category | Key capabilities | Setup complexity |
|---|---|---|---|
| GitHub | Source control | Issue sync, PR linking, comment sync, label sync, state mapping | Medium |
| GitLab | Source control | Issue sync, MR linking, label sync, state mapping | Medium |
| Slack | Communication | Slash commands, message shortcuts, state sync to threads, notifications | Low |
| Sentry | Error tracking | Link Sentry issues to work items, bidirectional state sync | Low |
| Draw.io | Diagramming | Embed diagrams in pages, inline editing, flowcharts, architecture diagrams | Low |
| Webhooks | Custom | Send real-time JSON payloads to any URL when events occur in SetGet | Low |
Integration categories
Source control
GitHub and GitLab integrations connect your code repositories to SetGet projects. Once connected, you can:
- Automatically create work items from issues filed in the repository.
- Link pull requests and merge requests to existing work items.
- Sync comments bidirectionally so conversations stay in one place.
- Map repository labels to SetGet labels.
- Define state mappings so that closing an issue in GitHub moves the corresponding SetGet work item to "Done".
Choose GitHub or GitLab based on where your repositories live. Both integrations offer equivalent functionality.
Communication
The Slack integration brings SetGet into the place where your team already communicates. Team members can create work items with a slash command, ask the SetGet AI assistant questions with an @mention, and receive automatic updates when work item state or assignee changes. Slack threads become lightweight conversation histories tied to specific work items.
Error tracking
The Sentry integration bridges the gap between production errors and project work. When Sentry detects a new issue, you can link it to an existing SetGet work item or create a new one directly. Resolving the work item in SetGet marks the Sentry issue as resolved, and vice versa.
Diagramming
The Draw.io integration embeds a full-featured diagram editor inside SetGet pages. Create flowcharts, system architecture diagrams, wireframes, ER diagrams, and more without leaving the application. Diagrams are stored alongside the page content, so they stay versioned and accessible.
Custom integrations via webhooks
When no built-in integration exists for a tool your team uses, webhooks fill the gap. Configure a webhook URL, select the events you care about, and SetGet sends a JSON payload to your endpoint every time that event occurs. Use webhooks to connect SetGet with CI/CD pipelines, custom dashboards, internal tools, or any service that accepts HTTP callbacks.
How to access integrations
- Open your workspace.
- Navigate to Settings in the sidebar.
- Select Integrations from the settings menu.
- Each integration has its own card with a Connect button and configuration panel.
Workspace admins can install and configure integrations. Members can use integrations that have already been connected but cannot modify their configuration.
Integration permissions
| Role | Can install | Can configure | Can use |
|---|---|---|---|
| Owner | Yes | Yes | Yes |
| Admin | Yes | Yes | Yes |
| Member | No | No | Yes |
| Guest | No | No | Limited |
TIP
Start with one integration and validate the sync behavior before enabling additional ones. This makes it easier to troubleshoot if something does not work as expected.
Data flow and privacy
- All integration data passes through the SetGet backend. No third-party service communicates directly with the frontend.
- OAuth tokens and API keys are encrypted at rest and never exposed to the browser.
- Webhook secrets are stored server-side and used for HMAC signature verification.
- You can disconnect an integration at any time. Disconnecting removes the OAuth link but does not delete work items or comments that were previously synced.
WARNING
Disconnecting an integration stops future syncing but does not roll back changes already applied to your work items. Review synced data before disconnecting.
Common use cases
| Scenario | Recommended integration |
|---|---|
| Track PRs against work items | GitHub or GitLab |
| Create work items from Slack conversations | Slack |
| Link production errors to work items | Sentry |
| Add architecture diagrams to project docs | Draw.io |
| Send work item events to a CI/CD pipeline | Webhooks |
| Send events to a custom analytics dashboard | Webhooks |
| Notify an external tool when a cycle completes | Webhooks |
Integration lifecycle
Every integration goes through the same lifecycle:
1. Connect
Authorize SetGet to communicate with the external service. Most integrations use OAuth, so you are redirected to the external service to grant permission. Once authorized, SetGet stores the token securely.
2. Configure
Set up the specific behaviors you want: which repositories to link, which events to subscribe to, how states map between systems, and which notifications to enable.
3. Operate
The integration runs automatically. Events in SetGet trigger outgoing sync, and events in the external service trigger incoming sync. Monitor activity in the integration settings panel.
4. Maintain
Periodically review integration health. OAuth tokens may expire and need renewal. Field mappings may need updates when your workflow changes. Check the integration status page for errors.
5. Disconnect (optional)
If an integration is no longer needed, disconnect it cleanly. This revokes the OAuth token and stops all syncing while preserving data that was already synced.
Multiple integrations
You can connect multiple integrations simultaneously. For example:
- GitHub for source control sync
- Slack for team communication
- Sentry for error tracking
- Webhooks for sending events to a CI/CD pipeline
Each integration operates independently. They do not interfere with each other.
Limits
| Aspect | Limit |
|---|---|
| Integrations per workspace | Unlimited |
| Webhooks per workspace | 25 |
| Webhook events per second | 50 (burst), 10 (sustained) |
| Linked repositories per project | 10 |
| Linked Slack channels per project | 10 |
Frequently asked questions
Can I connect the same GitHub organization to multiple workspaces?
Yes. Each workspace maintains its own OAuth connection. The same GitHub organization can be connected to multiple SetGet workspaces independently.
Do integrations work with self-hosted instances?
GitHub Cloud, GitLab Cloud, and Sentry Cloud are fully supported. Self-managed GitLab instances are supported by configuring the instance URL during setup. Self-hosted GitHub Enterprise requires additional configuration.
What happens to synced data if I disconnect an integration?
Synced work items, comments, and labels remain in SetGet. They become regular SetGet data that is no longer synced. No data is deleted when you disconnect.
Can I limit which members can use an integration?
Integrations are workspace-wide once connected. All members can use the features an integration provides. Only admins and owners can install, configure, or disconnect integrations.
Troubleshooting
If an integration is not working as expected:
- Check connection status -- go to Settings > Integrations and verify the integration shows a green "Connected" badge.
- Re-authorize -- OAuth tokens can expire. Click Reconnect to refresh the token.
- Check webhook logs -- for webhook integrations, review the delivery log for HTTP error codes.
- Verify permissions -- ensure the connected account has sufficient permissions in the external service (e.g., repository write access for GitHub).
- Review field mappings -- incorrect state or label mappings can cause unexpected behavior.
- Check rate limits -- if many events occur simultaneously, some may be delayed due to rate limiting.
- Review activity log -- the integration activity log shows recent sync events and any errors encountered.